{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5ead5284",
   "metadata": {},
   "source": [
    "# Vorkurs Tag 3 - Lösungen\n",
    "\n",
    "Author:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d07f21c7",
   "metadata": {},
   "source": [
    "## Aufgabe 3.1\n",
    "\n",
    "Schwierigkeit: 😈\n",
    "\n",
    "Schreibe ein Programm, welches 25 mal \"Hello World\" ausgibt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21a273d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(25):\n",
    "    print('Hello World')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "956c11b6",
   "metadata": {},
   "source": [
    "## Aufgabe 3.2\n",
    "\n",
    "Schwierigkeit: 😈\n",
    "\n",
    "Schreibe ein Programm, das `10 9 8 7 6 5 4 3 2 1 0 Bumm 0 1 2 3 4 5 6 7 8 9 10` ausgibt. \n",
    "\n",
    "Verwende dazu 2 Schleifen, Lists werden nicht benötigt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "88392c99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 9 8 7 6 5 4 3 2 1 0 Bumm 0 1 2 3 4 5 6 7 8 9 10 "
     ]
    }
   ],
   "source": [
    "for i in range(10, -1, -1):\n",
    "    print(i, end=' ')\n",
    "\n",
    "print('Bumm', end=' ')\n",
    "\n",
    "for i in range(11):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1727c78b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n",
      "3\n",
      "2\n",
      "1\n",
      "0\n",
      "Bumm\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in range(10, -1, -1):\n",
    "    print(i)\n",
    "\n",
    "print('Bumm')\n",
    "\n",
    "for i in range(11):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec0fe258",
   "metadata": {},
   "source": [
    "## Aufgabe 3.3\n",
    "\n",
    "Schwierigkeit: 😈😈\n",
    "\n",
    "Schreibe ein Programm, welches die ersten 15 ungeraden Zahlen ausgibt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7fb06464",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 ist ungerade\n",
      "3 ist ungerade\n",
      "5 ist ungerade\n",
      "7 ist ungerade\n",
      "9 ist ungerade\n",
      "11 ist ungerade\n",
      "13 ist ungerade\n",
      "15 ist ungerade\n",
      "17 ist ungerade\n",
      "19 ist ungerade\n",
      "21 ist ungerade\n",
      "23 ist ungerade\n",
      "25 ist ungerade\n",
      "27 ist ungerade\n",
      "29 ist ungerade\n"
     ]
    }
   ],
   "source": [
    "counter = 0\n",
    "output = 1\n",
    "while counter < 15: \n",
    "  if output % 2 != 0: \n",
    "    print(f\"{output} ist ungerade\")\n",
    "    counter += 1\n",
    "  output += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d4de7aae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n",
      "11\n",
      "13\n",
      "15\n",
      "17\n",
      "19\n",
      "21\n",
      "23\n",
      "25\n",
      "27\n",
      "29\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,30,2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20ee329e",
   "metadata": {},
   "source": [
    "## Aufgabe 3.4 \n",
    "\n",
    "#### Aufgabe 3.4.1.\n",
    "Schwierigkeit: 😈\n",
    "\n",
    "Zwei Studis, Bob und Alice, haben erfolgreich einige Klausuren bestanden. Alice hat ihre Noten zur besseren Übersicht in eine Liste geschrieben. \n",
    "Bob möchte es ihr nun gleich tun, weiß aber nicht wie er eine Liste erstellen soll. Könnt ihr ihm helfen? \n",
    "\n",
    "Bobs Noten sind wie folgt: In Datenbanken hatte er eine 2.0, in Informatik 1 eine 3.3, in Analysis eine 1.3 und in Englisch eine 1.0. Die Reihenfolge der Noten ist dabei nicht wichtig. \n",
    "\n",
    "Gebt die Liste danach aus. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e820fe6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.0, 3.3, 1.3, 1.0]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob_noten = [2.0, 3.3, 1.3, 1.0]\n",
    "bob_noten"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6be273d",
   "metadata": {},
   "source": [
    "#### Aufgabe 3.4.2\n",
    "Schwierigkeit: 😈\n",
    "\n",
    "In der Informatik 1-Einsicht hat sich herausgestellt, dass der Professor vergessen hat eine gesamte Aufgabe bei Bob zu werten. Seine Note verbessert sich dadurch auf eine 2.3. Natürlich muss das jetzt in seiner Liste geändert werden. \n",
    "\n",
    "Könnt ihr das für ihn übernehmen? Gebt danach die geänderte Liste aus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "bf937840",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.0, 2.3, 1.3, 1.0]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# je nachdem in welcher Reihenfolge ihr die Liste erstellt habt, müsst ihr den Index anpassen.\n",
    "\n",
    "bob_noten[1] = 2.3\n",
    "bob_noten"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e8e0513",
   "metadata": {},
   "source": [
    "#### Aufgabe 3.4.3.\n",
    "Schwierigkeit: 😈\n",
    "\n",
    "Bob hat noch zwei weitere Klausuren bestanden. In Statistik hat er eine 3.0 bekommen und in Wirtschaft eine 1.7. Fügt diese Noten in seine Liste ein. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "caf1f3a9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.0, 2.3, 1.3, 1.0, 3.0, 1.7]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob_noten.append(3.0)\n",
    "bob_noten.append(1.7)\n",
    "bob_noten"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d361005",
   "metadata": {},
   "source": [
    "#### Aufgabe 3.4.4. \n",
    "Schwierigkeit: 😈😈\n",
    "\n",
    "Alice und Bob möchten jetzt ihren Durchschnitt vergleichen. Errechnet für beide den Durchschnitt und gebt den besseren Durchschnitt aus. Nutzt dafür Schleifen.\n",
    "\n",
    "Eine Liste mit Alice Noten findet ihr unten:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fe78c9c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.75\n",
      "1.883333333333333\n",
      "1.75\n"
     ]
    }
   ],
   "source": [
    "# Lösung mit einer Schleife, da beide listen die gleiche Länge haben.\n",
    "alice_noten = [1.0, 1.3, 2.7, 2.0]\n",
    "\n",
    "alice_durchschnitt = 0\n",
    "bob_durchschnitt = 0\n",
    "\n",
    "for index in range(len(alice_noten)): \n",
    "    alice_durchschnitt += alice_noten[index]\n",
    "  \n",
    "    \n",
    "for index in range(len(bob_noten)):\n",
    "    bob_durchschnitt = bob_durchschnitt + bob_noten[index]\n",
    "\n",
    "alice_durchschnitt = alice_durchschnitt / len(alice_noten)\n",
    "bob_durchschnitt = bob_durchschnitt / len(bob_noten)\n",
    "\n",
    "print(alice_durchschnitt)\n",
    "print(bob_durchschnitt)\n",
    "\n",
    "if alice_durchschnitt > bob_durchschnitt:\n",
    "    print(bob_durchschnitt)\n",
    "elif alice_durchschnitt < bob_durchschnitt: \n",
    "    print(alice_durchschnitt)\n",
    "else: \n",
    "    print(\"Bob und Alice haben den gleichen Durchschnitt.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eab7b919",
   "metadata": {},
   "source": [
    "## Aufgabe 3.5\n",
    "\n",
    "Schwierigkeit: 😈😈\n",
    "\n",
    "Schreibe ein Programm, das ausgibt, wie viele Tage ein Monat hat. Erstelle dazu ein Dictionary, welche die Monatsnamen enthält, sowie die Anzahl der Tage in den jeweiligen Monaten. Schaltjahre sollen hier außer Acht gelassen werden.\n",
    "\n",
    "```python \n",
    "  anzahl_tage = {‘Januar’: 31, ......}\n",
    "```\n",
    "Mit Hilfe einer Schleife soll jetzt für jeden Monat ausgegeben werden, wie viele Tage dieser hat. Für den Monat Februar soll also z.B. „Der Monat Februar hat 28 Tage.“ ausgegeben werden."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6fef785e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Der Monat Januar hat 31 Tage.\n",
      "Der Monat Februar hat 28 Tage.\n",
      "Der Monat März hat 31 Tage.\n",
      "Der Monat April hat 30 Tage.\n",
      "Der Monat Mai hat 31 Tage.\n",
      "Der Monat Juni hat 20 Tage.\n",
      "Der Monat Juli hat 31 Tage.\n",
      "Der Monat August hat 31 Tage.\n",
      "Der Monat September hat 30 Tage.\n",
      "Der Monat Oktober hat 31 Tage.\n",
      "Der Monat November hat 30 Tage.\n",
      "Der Monat Dezember hat 31 Tage.\n"
     ]
    }
   ],
   "source": [
    "anzahl_tage = {'Januar': 31, 'Februar': 28, 'März': 31, 'April': 30,\n",
    "               'Mai': 31, 'Juni': 20, 'Juli': 31, 'August': 31,\n",
    "               'September': 30, 'Oktober': 31, 'November': 30,\n",
    "               'Dezember': 31}\n",
    "\n",
    "for monat, tage in anzahl_tage.items():\n",
    "    print(f'Der Monat {monat} hat {tage} Tage.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "64ecf850",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Der Monat Januar hat 31 Tage.\n",
      "Der Monat Februar hat 28 Tage.\n",
      "Der Monat März hat 31 Tage.\n",
      "Der Monat April hat 30 Tage.\n",
      "Der Monat Mai hat 31 Tage.\n",
      "Der Monat Juni hat 20 Tage.\n",
      "Der Monat Juli hat 31 Tage.\n",
      "Der Monat August hat 31 Tage.\n",
      "Der Monat September hat 30 Tage.\n",
      "Der Monat Oktober hat 31 Tage.\n",
      "Der Monat November hat 30 Tage.\n",
      "Der Monat Dezember hat 31 Tage.\n"
     ]
    }
   ],
   "source": [
    "for item in anzahl_tage.items():\n",
    "    print(f'Der Monat {item[0]} hat {item[1]} Tage.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f4f69124",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Der Monat Januar hat 31 Tage.\n",
      "Der Monat Februar hat 28 Tage.\n",
      "Der Monat März hat 31 Tage.\n",
      "Der Monat April hat 30 Tage.\n",
      "Der Monat Mai hat 31 Tage.\n",
      "Der Monat Juni hat 20 Tage.\n",
      "Der Monat Juli hat 31 Tage.\n",
      "Der Monat August hat 31 Tage.\n",
      "Der Monat September hat 30 Tage.\n",
      "Der Monat Oktober hat 31 Tage.\n",
      "Der Monat November hat 30 Tage.\n",
      "Der Monat Dezember hat 31 Tage.\n"
     ]
    }
   ],
   "source": [
    "# alternative ausgabe: \n",
    "for key in anzahl_tage:\n",
    "  print (f\"Der Monat {key} hat {anzahl_tage[key]} Tage.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42487252",
   "metadata": {},
   "source": [
    "## Aufgabe 3.6\n",
    "Schwierigkeit: 😈😈\n",
    "\n",
    "Die Zahlenfolge 1, 1, 2, 3, 5, 8, 13, . . . nennt man Fibonacci-Zahlen. Dabei entspricht jede Zahl in der Folge gerade der Summe ihrer beiden Vorgänger: 1+1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8, . . . Schreibe eine Schleife, die alle Fibonacci-Zahlen ausgibt, die kleiner als 1000 sind."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "03ae6909",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  1  2  3  5  8  13  21  34  55  89  144  233  377  610  987  "
     ]
    }
   ],
   "source": [
    "# Lösung 1 (schneller)\n",
    "zahl = 1\n",
    "vorgaenger = 1\n",
    "\n",
    "while vorgaenger < 1000:\n",
    "    print(vorgaenger, end='  ')\n",
    "    vorgaenger, zahl = zahl, zahl + vorgaenger\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ed584815",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Die Fibonacci-Zahlen:\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "144\n",
      "233\n",
      "377\n",
      "610\n",
      "987\n"
     ]
    }
   ],
   "source": [
    "# Lösung 2\n",
    "z1 = 1\n",
    "z2 = 1\n",
    "tempZ = 0\n",
    "print(\"Die Fibonacci-Zahlen:\\n1\")\n",
    "while z1 + z2 < 1000:\n",
    "  print(z2+z1)\n",
    "  tempZ = z1\n",
    "  z1 = z2\n",
    "  z2 = z1 + tempZ\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "441297b1",
   "metadata": {},
   "source": [
    "## Aufgabe 3.7\n",
    "\n",
    "#### Aufgabe 3.7.1\n",
    "\n",
    "Schwierigkeit: 😈😈\n",
    "\n",
    "Sei eine Liste mit Zahlen: \n",
    "\n",
    "```python\n",
    "liste = [19, -17, 31, 1, 42]\n",
    "```\n",
    "\n",
    "Suche in der gegebenen Liste nach der größten Zahl. Nutze dafür Schleifen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "23f74ae6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n",
      "42\n",
      "42\n"
     ]
    }
   ],
   "source": [
    "liste = [19, -17, 31, 1, 42]\n",
    "\n",
    "biggest = liste[0]\n",
    "for element in liste: \n",
    "  if biggest < element: \n",
    "      biggest = element\n",
    "\n",
    "print(biggest)\n",
    "\n",
    "# einzeiler mit cheats \n",
    "print(sorted(liste)[-1])\n",
    "# für die ganz faulen\n",
    "print(max(liste))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eb51cdc",
   "metadata": {},
   "source": [
    "#### Aufgabe 3.7.2\n",
    "\n",
    "Schwierigkeit: 😈😈\n",
    "\n",
    "Schreibe das obige Programm so um, dass du nun die Position in der Liste des Maximums ausgibst. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "aeb81396",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "biggest = 0\n",
    "for i in range(1, len(liste)): \n",
    "  if biggest < liste[i]: \n",
    "      biggest = i\n",
    "\n",
    "print(biggest)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e6fbb3e",
   "metadata": {},
   "source": [
    "# Zusatzaufgaben\n",
    "## Aufgabe 3.8\n",
    "\n",
    "Schwierigkeit: 😈😈😈\n",
    "\n",
    "Strings sind eigentlich nichts anderes als Liste von Charakteren. Dementsprechend kann man auf einzelne Charaktere wie Listenelemente zugreifen: \n",
    "\n",
    "```python \n",
    "str = \"Hallo Welt!\"\n",
    "str[1]\n",
    " # Ausgabe >>> 'a'\n",
    "```\n",
    "\n",
    "Nun möchte man erkennen ob ein Wort ein __Palindrom__ ist. Ein Palindrom ist ein Wort das von vorne oder hinten gelesen gleich ist. \n",
    "\n",
    "Zum Beispiel: Bob, Anna, Lagerregal, Kayak\n",
    "\n",
    "Schreibe ein Programm, welches Palindrome erkennt. \n",
    "\n",
    "Tipp: mit `.lower()` macht alle Buchstaben in einem String zu kleinen Buchstaben."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0a955dec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "str = \"Bobob\"\n",
    "str = str.lower()\n",
    "\n",
    "is_palindrom = True\n",
    "for i in range(0, int(len(str) / 2)): \n",
    "  j = len(str) - i - 1\n",
    "  if str[i] != str[j]:\n",
    "    is_palindrom = False\n",
    "\n",
    "print(is_palindrom)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce59e6a2",
   "metadata": {},
   "source": [
    "#### Aufgabe 3.8.1\n",
    "\n",
    "Schreibe ein Programm, welches einen String umdreht. Sprich: \n",
    "```\n",
    "    \"Hallo Welt\" --> \"tleW ollaH\"\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44d65f93",
   "metadata": {},
   "source": [
    "Mit slicing: [::-1] -> [start:stop:step]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "00fb7236",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tleW ollaH'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Hallo Welt\"[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42e6fc37",
   "metadata": {},
   "source": [
    "## Aufgabe 3.9\n",
    "Für die ganz schnellen 😜\n",
    "\n",
    "Schwierigkeit: 😈😈😈😈+\n",
    "\n",
    "Seien A und B zwei Listen unterschiedlicher Länge: \n",
    "\n",
    "```python \n",
    "\n",
    "  A = [4, 2, 1, 9, 10]\n",
    "  B = [5, 3, 1, 0, -1, 7]\n",
    "\n",
    "```\n",
    "\n",
    "Du sollst eine Lösung implementieren, die eine Listen, unabhängig von ihrer Länge, aufsteigend sortiert. \n",
    "Zum Sortieren vergleicht man zwei nebeneinanderliegende Listen-Elemente und überprüft ob das linke größer als das rechts ist. Ist das der Fall, dann werden die Elemente getauscht. Ansonsten nicht. \n",
    "\n",
    "Du musst nur eine Liste auf einmal sortieren. \n",
    "\n",
    "Tipp: du brauchst zwei Schleifen. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b690b5fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 5, 1, 0, -1, 7]\n",
      "[3, 1, 5, 0, -1, 7]\n",
      "[3, 1, 0, 5, -1, 7]\n",
      "[3, 1, 0, -1, 5, 7]\n",
      "[3, 1, 0, -1, 5, 7]\n",
      "[1, 3, 0, -1, 5, 7]\n",
      "[1, 0, 3, -1, 5, 7]\n",
      "[1, 0, -1, 3, 5, 7]\n",
      "[1, 0, -1, 3, 5, 7]\n",
      "[0, 1, -1, 3, 5, 7]\n",
      "[0, -1, 1, 3, 5, 7]\n",
      "[0, -1, 1, 3, 5, 7]\n",
      "[-1, 0, 1, 3, 5, 7]\n",
      "[-1, 0, 1, 3, 5, 7]\n",
      "[-1, 0, 1, 3, 5, 7]\n",
      "[-1, 0, 1, 3, 5, 7]\n"
     ]
    }
   ],
   "source": [
    "A = [4, 2, 1, 9, 10]\n",
    "B = [5, 3, 1, 0, -1, 7]\n",
    "\n",
    "len_arr = len(B)\n",
    "arr = B\n",
    "\n",
    "# iteriere über alle Listenelemente\n",
    "for i in range(0, len_arr -1): \n",
    "  # iteriere über alle Listenelemente bis zum Vorletzten \n",
    "  for j in range(0, len_arr - i - 1): \n",
    "    # wenn das linke Element größer als das rechter ist, dann tausche\n",
    "    if arr[j] > arr[j + 1]:\n",
    "      arr[j], arr[j + 1] = arr[j + 1], arr[j]\n",
    "    \n",
    "      # oder mit temporärer Variable: \n",
    "      # t = arr[j]\n",
    "      # arr[j] = arr[j+1]\n",
    "      # arr[j+1] = t\n",
    "\n",
    "\n",
    "print(arr)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "vscode": {
   "interpreter": {
    "hash": "ad2bdc8ecc057115af97d19610ffacc2b4e99fae6737bb82f5d7fb13d2f2c186"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}