Programming_course_Day3_student_version.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################### Day 3 ###########################################\n",
    "\n",
    "#Wieder Besprechung der Hausaufgaben\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Funktionen - Juhu!\n",
    "\n",
    "def sag_hallo():\n",
    "\tprint(\"Hallo!\")\n",
    "\n",
    "sag_hallo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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": [
    "#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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Aufgabe\n",
    "#schreibe eine Funktion, die eine Liste von Zahlen bekommt und das kleinste Element zurückgibt\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": 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": null,
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(coordinates[0][0])\n",
    "print(coordinates[1][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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 #############"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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"
   ]
  },
  {
   "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
}