Programming_course_Day3_teacher_version.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################### Day 3 ###########################################\n",
    "\n",
    "#Wieder Besprechung der Hausaufgaben\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rate meine Zahl: 6\n",
      "Das ist leider nicht meine Zahl\n"
     ]
    }
   ],
   "source": [
    "#imports and guessing game\n",
    "\n",
    "import random\n",
    "\n",
    "mini = 1\n",
    "maxi = 10\n",
    "r = random.randint(mini,maxi)\n",
    "if int(input(\"Rate meine Zahl: \")) == r:\n",
    "\tprint(\"Richtig, super geraten!\")\n",
    "else:\n",
    "\tprint(\"Das ist leider nicht meine Zahl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rate meine Zahl: 3\n",
      "zu klein\n",
      "Rate meine Zahl: 60\n",
      "zu groß\n",
      "Rate meine Zahl: 40\n",
      "zu klein\n",
      "Rate meine Zahl: 50\n",
      "zu klein\n",
      "Rate meine Zahl: 55\n",
      "zu klein\n",
      "Rate meine Zahl: 58\n",
      "zu groß\n",
      "Rate meine Zahl: 57\n",
      "zu groß\n",
      "Rate meine Zahl: 56\n",
      "Richtig, das war meine Zahl!\n"
     ]
    }
   ],
   "source": [
    "#Aufgabe\n",
    "#programmiere das Ratespiel, wobei das Programm eine zufällige Zahl zwischen 1 und 100 wählt und man mehrfach raten kann.\n",
    "#Das Programm soll einem nach jedem mal raten sagen, ob die geratene Zahl größer, gleich oder kleiner als die gesuchte Zahl ist.\n",
    "\n",
    "#Lösung\n",
    "\n",
    "mini = 1\n",
    "maxi = 100\n",
    "r = random.randint(mini, maxi)\n",
    "guess = 0\n",
    "while (guess != r):\n",
    "\tguess = int(input(\"Rate meine Zahl: \"))\n",
    "\tif guess > r:\n",
    "\t\tprint(\"zu groß\")\n",
    "\telif guess < r:\n",
    "\t\tprint(\"zu klein\")\n",
    "print(\"Richtig, das war meine Zahl!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo!\n"
     ]
    }
   ],
   "source": [
    "#Funktionen - Juhu!\n",
    "\n",
    "def sag_hallo():\n",
    "\tprint(\"Hallo!\")\n",
    "\n",
    "sag_hallo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo, ich bin Simon.\n",
      "Ich bin 17 Jahre alt.\n",
      "Ich studiere in Heidelberg Physik.\n",
      "Ich war 3 Jahre im Science Lab\n",
      "und ich mag Informatik.\n",
      "Hallo, ich bin Simon.\n",
      "Ich bin 17 Jahre alt.\n",
      "Ich studiere in Heidelberg Physik.\n",
      "Ich war 3 Jahre im Science Lab\n",
      "und ich mag Informatik.\n"
     ]
    }
   ],
   "source": [
    "#verkürzen, verschönern und vereinfachen Code:\n",
    "\n",
    "def vorstellen():\n",
    "\tprint(\"Hallo, ich bin Simon.\")\n",
    "\tprint(\"Ich bin 17 Jahre alt.\")\n",
    "\tprint(\"Ich studiere in Heidelberg Physik.\")\n",
    "\tprint(\"Ich war 3 Jahre im Science Lab\")\n",
    "\tprint(\"und ich mag Informatik.\")\n",
    "\n",
    "\n",
    "vorstellen()\n",
    "vorstellen()#wenn man sich mehrfach vorstellen muss, muss man nur die Funktion mehrfach aufrufen, nicht die ganzen prints nochmal schreiben\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hallo ich bin Simon.\n",
      "Hallo ich bin Marvin.\n"
     ]
    }
   ],
   "source": [
    "#Parameter\n",
    "\n",
    "def vorstellen2(name):#wichtig ist generell, dass ihr unterschiedliche Variablen und Funktionen auch unterschiedlich benennt\n",
    "\tprint(\"Hallo ich bin \" + name + \".\")\n",
    "\n",
    "\n",
    "vorstellen2(\"Simon\")\n",
    "vorstellen2(\"Marvin\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "\tprint(2*x**2 + 3*x - 5)\n",
    "\n",
    "\n",
    "f(1)\n",
    "f(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "#return\n",
    "\n",
    "def f2(x):\n",
    "\treturn 2*x**2 + 3*x - 5 #return ist sehr nützlich, wenn man das Ergebnis wiederverwenden will\n",
    "\n",
    "y = f2(1)\n",
    "print(y)\n",
    "\n",
    "print(f2(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def g(x,y):#es gehen auch mehrere Parameter\n",
    "\treturn (x+y)**2\n",
    "\n",
    "g(2,3)\n",
    "g(7,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "20100\n",
      "12502500\n"
     ]
    }
   ],
   "source": [
    "#Aufgabe\n",
    "#schreibe eine Funktion, die eine Zahl n als Parameter bekommt und dann die Summe aller Zahlen von 1 bis n zurück gibt\n",
    "#führe die Funktion für die Werte n=10, n=200, n=5000 aus und gebe das Ergebnis aus\n",
    "\n",
    "#Lösung\n",
    "def sum_to_n(n):\n",
    "\tres = 0\n",
    "\tfor i in range(n+1):\n",
    "\t\tres += i\n",
    "\treturn res\n",
    "\n",
    "print(sum_to_n(10))\n",
    "print(sum_to_n(200))\n",
    "print(sum_to_n(5000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-6\n"
     ]
    }
   ],
   "source": [
    "#Aufgabe\n",
    "#schreibe eine Funktion, die eine Liste von Zahlen bekommt und das kleinste Element zurückgibt\n",
    "\n",
    "#Lösung\n",
    "def min_of_list(list1):\n",
    "\tmini = list1[0]\n",
    "\tfor item in list1:\n",
    "\t\tif item < mini:\n",
    "\t\t\tmini = item\n",
    "\treturn mini\n",
    "\n",
    "\n",
    "print(min_of_list([5,776,2,43,-6,13]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "!ollaH\n",
      "RACECAR\n"
     ]
    }
   ],
   "source": [
    "def reverse(string):\n",
    "\trev_string = \"\"\n",
    "\tfor i in range(1,len(string)+1):\n",
    "\t\trev_string += string[-i]\n",
    "\treturn rev_string\n",
    "\n",
    "print(reverse(\"Hallo!\"))\n",
    "print(reverse(\"RACECAR\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Aufgabe\n",
    "#schreibe eine Funktion rotate_string, die einen String s und eine Zahl k bekommt, und den String um k rotiert.\n",
    "#Bei einer Rotation um 1 wird das letzte Zeichen an den Anfang gesetzt. Bei einer Rotation um k wird dies k mal hintereinander ausgeführt\n",
    "\n",
    "#Tipp: ihr könnt, müsst aber nicht, Slices verwenden\n",
    "\n",
    "#relativ einfache Version: k <= len(s)\n",
    "\n",
    "#etwas schwerere Version: k darf größer als len(s) sein (aber kleiner als 10^8). \n",
    "\n",
    "#noch schwerere Version: k darf riesig sein (bis zu 10^18). Beachte, dass du nicht so viele Operationen ausführen kannst,\n",
    "#du kannst also nicht einfach k mal eins weiter rotieren.\n",
    "\n",
    "\n",
    "#Lösung einfache Version\n",
    "\n",
    "def rotate_string(string, k):\n",
    "\treturn string[-k:] + string[:-k]\n",
    "\n",
    "#Lösung etwas schwerere Version\n",
    "\n",
    "def rotate_string(string, k):\n",
    "\tfor i in range(k):\n",
    "\t\tstring = string[-1] + string[:-1]\n",
    "    return string\n",
    "\n",
    "#Lösung noch schwerere Version\n",
    "\n",
    "def rotate_string(string, k):\n",
    "\treturn string[-(k%len(string)):] + string[:-(k%len(string))]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "#verschachtelte (2 dimensionale) Listen\n",
    "\n",
    "coordinates = [[10,25],[14,17]]\n",
    "\n",
    "def manhatten_distance(coords):\n",
    "\treturn abs(coords[0][0] - coords[1][0]) + abs(coords[0][1] - coords[1][1])#abs ist der Betrag\n",
    "\n",
    "#Indexe bei 2D Listen erklären\n",
    "print(manhatten_distance(coordinates))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "print(coordinates[0][0])\n",
    "print(coordinates[1][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "number_sequences = [] #soll so aussehen: [[1],[1,2],[1,2,3],...]\n",
    "\n",
    "############### Achtung gemeiner Fehler! ###################\n",
    "l = []\n",
    "for i in range(10):\n",
    "    l.append(i)\n",
    "    number_sequences.append(l) #appended immer nur einen Pointer zu der Liste l\n",
    "print(number_sequences)\n",
    "##################### so funktioniert das nicht #############\n",
    "\n",
    "#Referenzen und Pointer erklären --> Unterschied zwischen komplexen Datentypen und primitiven Datentypen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 5], [0, 1, 2, 3, 4, 5, 6], [0, 1, 2, 3, 4, 5, 6, 7], [0, 1, 2, 3, 4, 5, 6, 7, 8], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]\n"
     ]
    }
   ],
   "source": [
    "#richtige Lösung\n",
    "from copy import deepcopy #um eine neue Kopie zu machen und nicht nur die Referenz zu speichern\n",
    "\n",
    "number_sequences = [] #soll so aussehen: [[0],[0,1],[0,1,2],[0,1,2,3],...]\n",
    "l = []\n",
    "for i in range(10):\n",
    "    l.append(i)\n",
    "    cp = deepcopy(l)#Liste l kopieren\n",
    "    #Achtung! Die Liste l kann nicht einfach durch cp = l kopiert werden, da das auch nur eine Referenz setzt\n",
    "    number_sequences.append(cp) #Referenz zur neuen kopierten Liste speichern\n",
    "print(number_sequences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 15]\n"
     ]
    }
   ],
   "source": [
    "#Hausaufgabe 1\n",
    "#Schreibe eine Funktion, die zwei Koordinaten (2er-Tupel) bekommt. Eine Person startet bei der ersten Koordinate \n",
    "#und will schrittweise zur zweiten Koordinate laufen.\n",
    "#Schreibe eine Funktion, die einen Weg von der Startposition zur Endposition findet. Die Funktion soll alle Koordinaten auf\n",
    "#diesem Weg printen.\n",
    "\n",
    "#Beispiel: Start: [11,15], Ende: [13,11]\n",
    "#möglicher Output: [11,15],[12,15],[13,15],[13,14],[13,13],[13,12],[13,11]\n",
    "\n",
    "#Lösung\n",
    "def go_path(start,end):\n",
    "\tprint(start)\n",
    "\twhile (start[0] != end[0]):\n",
    "\t\tif start[0] > end[0]:\n",
    "\t\t\tstart[0] -= 1\n",
    "\t\telse:\n",
    "\t\t\tstart[0] += 1\n",
    "\t\tprint(start)\n",
    "\twhile (start[1] != end[1]):\n",
    "\t\tif start[1] > end[1]:\n",
    "\t\t\tstart[1] -= 1\n",
    "\t\telse:\n",
    "\t\t\tstart[1] += 1\n",
    "\t\tprint(start)\n",
    "\t\n",
    "go_path([11,15],[11,15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FKGIGTOCPGPITGKHGPCP\n",
      "DIEGERMANENGREIFENAN\n"
     ]
    }
   ],
   "source": [
    "#Hausaufgabe 2 (schwer)\n",
    "#Vielleicht hast du schonmal was von der Caesar Verschlüsselung gehört. Diese funktioniert wie folgt:\n",
    "#Du hast einen Nachricht als String und möchtest diese verschlüsseln.\n",
    "#Du nimmst dir eine Zahl k zwischen 0 und 25 (am besten nicht 0), welche der Schlüssel für deine Verschlüsselung ist.\n",
    "#Nun schaust du für jeden Buchstaben in deinem String, an welcher Stelle im Alphabet dieser steht.\n",
    "#Disen Buchstaben ersetzt du nun mit dem Buchstaben, der k Stellen weiter hinten im Alphabet steht (nach Z fängst du einfach wieder mit A an)\n",
    "#Die Entschlüsselung soll das wieder Rückgängig machen.\n",
    "#In unserem Fall besteht der String nur aus Großbuchstaben.\n",
    "\n",
    "#Programmiere ceasar_enc und ceasar_dec, die eine Nachricht encrypten oder decrypten sollen. (Tipp: Du kannst die rotate_string Funktion verwenden)\n",
    "#Teste dein Programm\n",
    "\n",
    "#Beispiel: ceasar_enc(\"DIEGERMANENGREIFENAN\", 2) --> FKGIGTOCPGPITGKHGPCP\n",
    "#und ceasar_dec(\"FKGIGTOCPGPITGKHGPCP\", 2) --> DIEGERMANENGREIFENAN\n",
    "\n",
    "\n",
    "def rotate_string(string, k):\n",
    "\treturn string[-(k%len(string)):] + string[:-(k%len(string))]\n",
    "\n",
    "\n",
    "alph = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "\n",
    "def ceasar_enc(message, k):\n",
    "\tenc_message = ...\n",
    "\treturn enc_message\n",
    "\n",
    "def ceasar_dec(enc_message, k):\n",
    "\tmessage = ...\n",
    "\treturn message\n",
    "\n",
    "\n",
    "#Lösung\n",
    "\n",
    "def rotate_string(string, k):\n",
    "\treturn string[-(k%len(string)):] + string[:-(k%len(string))]\n",
    "\n",
    "alph = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n",
    "\n",
    "def ceasar_enc(message, k):\n",
    "\trot_alph = rotate_string(alph, k)\n",
    "\tenc_message = \"\"\n",
    "\tfor c in message:\n",
    "\t\tenc_message += alph[rot_alph.index(c)]\n",
    "\treturn enc_message\n",
    "\n",
    "def ceasar_dec(enc_message, k):\n",
    "\tmessage = ceasar_enc(enc_message, -k)\n",
    "\treturn message\n",
    "\n",
    "s = \"DIEGERMANENGREIFENAN\"\n",
    "enc = ceasar_enc(s,2)\n",
    "print(enc)\n",
    "print(ceasar_dec(enc,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}