061_Arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e0c58392",
   "metadata": {},
   "source": [
    "# Arrays\n",
    "#### Marcel Lüthi, Andreas Morel-Forster<br/>Departement Mathematik und Informatik, Universität Basel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c047146",
   "metadata": {},
   "source": [
    "### Array vs. String\n",
    "\n",
    "Strings sind im Prinzip nicht viel mehr als ein Array von Zeichen und noch jede Menge nützlicher Funktionen.\n",
    "\n",
    "Die Länge eines Strings `s` bekommen Sie mit der Methode `s.length()`. Anders als bei einem Array `a` wo die Länge mit `a.length`, also ohne Klammern abgefragt wird.\n",
    "\n",
    "Auch auf ein Element, also ein Buchstaben, können Sie bei einem String zugreifen. Um auf das `i`-te Element zuzugreifen benötigen Sie bei einem Array `a` die eckigen Klammern `a[i]`, bei einem String `s` jedoch die Methode `s.charAt(i)`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8817d442",
   "metadata": {},
   "source": [
    "#### Miniübung\n",
    "- Ergänzen Sie die Methode `reverse` welche einen als `String` übergebenen Text umgedreht und zurück gibt.\n",
    "- Versuchen Sie eine `for`-Schleife zu verwenden, welche von hinten nach vorne über die Buchstaben iteriert."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3a65ceaf",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Reverse {\n",
    "    public static String reverse(String forward) {\n",
    "        String backwards = \"\";\n",
    "        \n",
    "        // Ihre Lösung kommt hier hin\n",
    "        for (int idx = forward.length() - 1 ; idx >= 0 ; idx = idx - 1) {\n",
    "            backwards = backwards + forward.charAt(idx);\n",
    "        }\n",
    "        \n",
    "        return backwards;\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(reverse(\"!ednenehcoW tsi negroM - repuS\"));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "abb8c88d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Super - Morgen ist Wochenende!\n"
     ]
    }
   ],
   "source": [
    "Reverse.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bee49de",
   "metadata": {},
   "source": [
    "### Return - Schneller Rücksprung aus einer Funktion\n",
    "\n",
    "Mit einer `return`-Anweisung können wir nicht nur am Ende etwas zurück geben, sondern auch an anderen Stellen schnell aus einer Funktion zurück springen. Dabei muss der in der Deklaration angegebene Typ, für den Rückgabewert, eingehalten werden."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04152dea",
   "metadata": {},
   "source": [
    "Das Nachfolgende Beispiel zeigt Code, welcher überprüft ob ein Text ein Anagram ist. Ein Anagram ist ein Text, welcher von vorne wie von hinten gelesen die selbe Folge von Buchstaben hat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8dcc1154",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class Anagram {\n",
    "    \n",
    "    public static char toLowerCase(char c) {\n",
    "        boolean isLowercaseLetter = ('a' <= c && c <= 'z');\n",
    "        if (isLowercaseLetter) {\n",
    "            return c;\n",
    "        } else {\n",
    "            boolean isUppercaseLetter = (c >= 'A' && c <= 'Z');\n",
    "            if ( isUppercaseLetter ) {\n",
    "                return (char) ('a' + (c - 'A'));\n",
    "            } else {\n",
    "                return c;\n",
    "            }\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    public static boolean check(String text) {\n",
    "        for (int i = 0; i < text.length()/2; i = i + 1) {\n",
    "            char lowerFront = toLowerCase( text.charAt(i) );\n",
    "            char lowerBack = toLowerCase( text.charAt(text.length()-1-i) );\n",
    "            if ( lowerFront != lowerBack ) {\n",
    "                return false;\n",
    "            }\n",
    "        }\n",
    "        return true;\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(check(\"otto\"));\n",
    "        System.out.println(check(\"Anna\"));\n",
    "        System.out.println(check(\"Lagerregal\"));\n",
    "        System.out.println(check(\"Irgendwas\"));\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abcf254a",
   "metadata": {},
   "outputs": [],
   "source": [
    "Anagram.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38467932",
   "metadata": {},
   "source": [
    "### Initialisierung 2d-Array\n",
    "- Erstellen Sie ein zweidimensionales Array, für welches folgendes gilt: ```a[i].length = i``` wobei ```i``` ein ganzzahliger Index ist, welcher von ```0``` bis ```9``` läuft.\n",
    "- Füllen Sie die Arrays jeweils mit den Zahlen von `0` aufsteigend bis `i`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ac0eabae",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class TriangleArray {\n",
    "\n",
    "    public static void printArray(int[][] array) {\n",
    "        for(int[] row : array) {\n",
    "            \n",
    "            for(int i = 0; i < row.length; i = i + 1) {\n",
    "                int value = row[i];\n",
    "                \n",
    "                \n",
    "                System.out.print(value + \" \");\n",
    "            }\n",
    "            \n",
    "            \n",
    "            \n",
    "            for(int value : row) {\n",
    "                System.out.print(value + \" \");\n",
    "            }\n",
    "            \n",
    "            \n",
    "            \n",
    "            \n",
    "            System.out.println();\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void main(String[] args) {\n",
    "        // Ihre Lösung kommt hier hin\n",
    "        int numberOfArray = 10;\n",
    "        int[][] a = new int[numberOfArray][];\n",
    "        for(int i = 0; i < a.length; i = i + 1) {\n",
    "            a[i] = new int[i];\n",
    "            for(int j = 0; j < a[i].length; j = j + 1) {\n",
    "                a[i][j] = j;\n",
    "            }\n",
    "        }\n",
    "        \n",
    "        \n",
    "        printArray(a);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a2761458",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "0 \n",
      "0 1 \n",
      "0 1 2 \n",
      "0 1 2 3 \n",
      "0 1 2 3 4 \n",
      "0 1 2 3 4 5 \n",
      "0 1 2 3 4 5 6 \n",
      "0 1 2 3 4 5 6 7 \n",
      "0 1 2 3 4 5 6 7 8 \n"
     ]
    }
   ],
   "source": [
    "TriangleArray.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d329f765",
   "metadata": {},
   "source": [
    "### Randbedingungen - Rule 30\n",
    "\n",
    "Idee: Gegeben ein Array vom Typ `boolean`-Array berechnen wir ein neues Array mit anderen Werten nach einem bestimmten Schema.\n",
    "![Idee Zeilenweise](./images/rule30_rows.png)\n",
    "\n",
    "Der neue Zustand einer Zelle berechnet sich aus dem alten Zustand der Zelle und der beiden direkten Nachbarn.\n",
    "![Regeln](./images/rule30_rules.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2c7905c",
   "metadata": {},
   "source": [
    "#### Miniübung\n",
    "\n",
    "Der folgende Code hat ein Problem in der Funktion `evolve`.\n",
    "\n",
    "- Führen Sie den Code aus und schauen Sie sich den Fehler an. Diskutieren Sie in klein Gruppen was passiert.\n",
    "- Korrigieren Sie den Code mit zirkulärem Zugriff."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3edd3916",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "public class Rule30 {\n",
    "    \n",
    "    public static boolean rule30(boolean b1, boolean b2, boolean b3) {\n",
    "        if (b1 && b2 && b3) {\n",
    "            return false; // 2 ^ 7 = 128\n",
    "        }\n",
    "        if (b1 && b2 && !b3) {\n",
    "            return false; // 2 ^ 6 = 64\n",
    "        }\n",
    "        if (b1 && !b2 && b3) {\n",
    "            return false; // 2 ^ 5 = 32\n",
    "        }\n",
    "        if (b1 && !b2 && !b3) {\n",
    "            return true; // 2 ^ 4 = 16\n",
    "        }\n",
    "        if (!b1 && b2 && b3) {\n",
    "            return true; // 2 ^ 3 = 8\n",
    "        }\n",
    "        if (!b1 && b2 && !b3) {\n",
    "            return true; // 2 ^ 2 = 4\n",
    "        }\n",
    "        if (!b1 && !b2 && b3) {\n",
    "            return true; // 2 ^ 1 = 2\n",
    "        }\n",
    "        if (!b1 && !b2 && !b3) {\n",
    "            return false; // 2 ^ 0 = 1\n",
    "        }\n",
    "        return false;\n",
    "    }\n",
    "    \n",
    "    public static boolean[] evolve(boolean[] line) {\n",
    "        boolean[] nextLine = new boolean[line.length];\n",
    "        for (int idx = 0; idx < line.length; idx = idx + 1) {\n",
    "            int leftIndex = (idx - 1 + line.length) % line.length;\n",
    "            int rightIndex = (idx + 1) % line.length;\n",
    "            \n",
    "            nextLine[idx] = rule30(line[leftIndex], line[idx],line[rightIndex]);\n",
    "        }\n",
    "        return nextLine;\n",
    "    }\n",
    "    \n",
    "    public static boolean[] init(int n) {\n",
    "        boolean[] line = new boolean[n];\n",
    "        line[n/2] = true;\n",
    "        return line;\n",
    "    }\n",
    "    \n",
    "    public static void printLine(boolean[] line) {\n",
    "        for(int i = 0; i < line.length; i = i + 1) {\n",
    "            if (line[i]) {\n",
    "                System.out.print(\"#\");\n",
    "            } else {\n",
    "                System.out.print(\".\");\n",
    "            }\n",
    "        }\n",
    "        System.out.println();\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        System.out.println(\"Rule 30 - Visualization\");\n",
    "        final int LINE_LENGTH = 40;\n",
    "        final int MAX_ITERATIONS = 12;\n",
    "        boolean[] current = init(LINE_LENGTH);\n",
    "        int remainingSteps = MAX_ITERATIONS;\n",
    "        do {\n",
    "            printLine(current);\n",
    "            current = evolve(current);\n",
    "            remainingSteps = remainingSteps - 1;\n",
    "        } while (remainingSteps > 0);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a8cfd21a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rule 30 - Visualization\n",
      "....................#...................\n",
      "...................###..................\n",
      "..................##..#.................\n",
      ".................##.####................\n",
      "................##..#...#...............\n",
      "...............##.####.###..............\n",
      "..............##..#....#..#.............\n",
      ".............##.####..######............\n",
      "............##..#...###.....#...........\n",
      "...........##.####.##..#...###..........\n",
      "..........##..#....#.####.##..#.........\n",
      ".........##.####..##.#....#.####........\n"
     ]
    }
   ],
   "source": [
    "Rule30.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2350f33",
   "metadata": {},
   "source": [
    "### Referenzen - Alles klar?\n",
    "\n",
    "Überlegen Sie zuerst bevor Sie die Zellen ausführen: Was wird bei den Folgenden Programmen ausgegeben? Deckt sich die Ausgabe mit Ihrer Erwartung? Können Sie das Beobachtete erklären?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a987522",
   "metadata": {},
   "source": [
    "#### Beispiel 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8cdcefb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class References {\n",
    "    public static void print(int[] array) {\n",
    "        for(int value : array) {\n",
    "            System.out.print(value + \" \");\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void hiddenAdder(int[] array) {\n",
    "        array[2] = array[0] + array[1];\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        int[] array = new int[]{1, 2, 0};\n",
    "        hiddenAdder(array);\n",
    "        print(array);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f52be946",
   "metadata": {},
   "outputs": [],
   "source": [
    "References.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15d2676c",
   "metadata": {},
   "source": [
    "#### Beispiel 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d6d96a5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class References {\n",
    "    public static void print(int[] array) {\n",
    "        for(int value : array) {\n",
    "            System.out.print(value + \" \");\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void hiddenAdder(int[] array) {\n",
    "        array = new int[]{1, 2, 3};\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        int[] array = new int[]{1, 2, 0};\n",
    "        hiddenAdder(array);\n",
    "        print(array);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acf15c5c",
   "metadata": {},
   "outputs": [],
   "source": [
    "References.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b856ec3d",
   "metadata": {},
   "source": [
    "#### Beispiel 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08cd1276",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class References2d {\n",
    "    public static void print(int[][] array) {\n",
    "        for(int[] row : array) {\n",
    "            for(int value : row) {\n",
    "                System.out.print(value + \" \");\n",
    "            }\n",
    "            System.out.println();\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void hiddenAdder(int[][] array) {\n",
    "        array[0][2] = array[0][0] + array[0][1];\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        int[][] array = new int[][]{{1, 2, 0}};\n",
    "        hiddenAdder(array);\n",
    "        print(array);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcb1907e",
   "metadata": {},
   "outputs": [],
   "source": [
    "References2d.main(new String[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d60d6c67",
   "metadata": {},
   "source": [
    "#### Beispiel 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a60cd9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "public class References2d {\n",
    "    public static void print(int[][] array) {\n",
    "        for(int[] row : array) {\n",
    "            for(int value : row) {\n",
    "                System.out.print(value + \" \");\n",
    "            }\n",
    "            System.out.println();\n",
    "        }\n",
    "    }\n",
    "\n",
    "    public static void hiddenAdder(int[][] array) {\n",
    "        array[0] = new int[]{1, 2, 3};\n",
    "    }\n",
    "    \n",
    "    public static void main(String[] args) {\n",
    "        int[][] array = new int[][]{{1, 2, 0}};\n",
    "        hiddenAdder(array);\n",
    "        print(array);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b25428c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "References2d.main(new String[0]);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "17.0.4+8-jvmci-22.2-b06"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}