{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 3. Hausaufgabe\n",
"\n",
"Geben Sie diese Hausaufgabe gemeinsam mit Ihrem/r Partner/in ab. Füllen Sie dazu dieses Notebook aus und speichern Sie es ab (Disketten-Icon oben links). Laden Sie dann die Datei (`hausaufgabe3.ipynb`) in Moodle hoch. Verwenden Sie Kommentare im Python-Quellcode und Markdown-Textboxen im Jupyter-Notebook ([Syntax-Beispiele](https://de.wikipedia.org/wiki/Markdown#Auszeichnungsbeispiele)) um ihr Programm zu kommentieren. Für diese Hausaufgabe sollten Sie das 4. bis 6. Kapitel durchgearbeitet haben, da Rekursion, Verzweigungen und Funktionen mit Rückgabewert benötigt werden.\n",
"\n",
"\n",
"* Geben Sie bitte Ihrem **Notebook einen Namen**, sodass es Ihnen und Ihrem Partner zugeordnet werden kann (z.B. *hausaufgabe2_nachname1_nachname2.ipynb*)\n",
"* Fügen Sie außerdem **Kommentare** zu ihrem Code hinzu, mit denen Sie erklären, was die Funktion macht (Schleife, Bedingungen, etc. beschreiben). Dies kann man durch zwei Varianten machen:\n",
" - \\# \n",
" - Mit Hilfe der Raute kann ein Kommentar in einem Codeblock stehen, um einzelne Codesgemente zu beschreiben und zu interpretieren\n",
" - z.B. : # Kommentar zu einzelnen Code-Segmenten\n",
" - ''' '''\n",
" - Hier kann ein Kommentar stehen, der die Funktion als Ganzes beschreibt\n",
" - z.B. ''' Beschreibung einer Funktion '''\n",
" \n",
"Wir wünschen viel Erfolg beim Lösen der Aufgaben!\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Aufgabe 1\n",
"\n",
"Stellen Sie sich vor, Sie spielen Schere-Stein-Papier mit ihrer Partner\\*in.\n",
"\n",
"Wer das Spiel nicht kennt:\n",
"Zwei Spieler\\*innen müssen sich gleichzeitig für eins der drei Symbole (Schere, Stein oder Papier) entscheiden. \n",
"Der Gewinner wird folgendermaßen ermittelt:\n",
"- Stein schlägt Schere\n",
"- Schere schlägt Papier\n",
"- Papier schlägt Stein\n",
"\n",
"Falls beide Spieler\\*innen dasselbe Symbol ausgewählt haben, wird noch einmal gespielt.\n",
"\n",
"Ihre Aufgabe ist es, einen Durchlauf des Spiels zu implementieren.\n",
"\n",
"1. Schreiben Sie eine Funktion `schere_stein_papier`, die zwei Zeichenketten als Argumente erwartet und \"Spieler\\*in 1 gewinnt\" oder \"Spieler\\*in 2 gewinnt\" ausgibt, abhängig davon, ob Argument 1 gegen Argument 2 gewinnt oder umgedreht.\n",
" - Falls die **Argumente gleich** sind, soll eine Mitteilung gemacht werden, dass noch einmal gespielt werden muss. \n",
" - Decken Sie auch den Fall ab, dass ein Argument eine **andere Zeichenkette** sein kann, z.B. \"Brunnen\". Hier soll eine Warnung gezeigt werden, dass einer der Spieler\\*innen versucht, zu betrügen. \n",
"\n",
"2. Schreiben Sie eine Funktion, die die **Nutzer\\*in bittet, zwei Zeichenketten einzugeben** und dann die Funktion `schere_stein_papier` nutzt, um zu entscheiden, welche Spieler\\*in gewonnen hat.\n",
"\n",
"3. **Freiwillig und zum Knobeln**: Schreiben Sie eine Funktion, die drei Durchläufe `schere-stein-papier` spielt und den Gesamtsieger ermittelt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" # Implementieren Sie hier die Funktionen\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Rufen Sie hier ihre Funktionen auf, um sie zu testen"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Aufgabe 2\n",
"\n",
"*(Dies ist [Aufgabe 4 im 5. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar05.ipynb#aufgabe-4).)*\n",
"\n",
"Was gibt das folgende Programm aus? Zeichnen Sie (entweder mit Stift und Papier oder in einem Markdown Feld, siehe ein Beispiel unten) ein Stapeldiagramm (siehe [Abschnitt 3.9](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar03.ipynb#3-9-stapel-diagramme)), das den Zustand des Programms ausgibt, wenn `recurse(3, 0)` aufgerufen wird: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"def recurse(n, s):\n",
" if n == 0:\n",
" print(s)\n",
" else:\n",
" recurse(n-1, n+s)\n",
"\n",
"recurse(5, 0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`?\n",
"\n",
"2. Fügen Sie einen Docstring zur Funktion hinzu, der alles erklärt, was man wissen sollte, um diese Funktion nutzen zu können (und nicht mehr!).\n",
"\n",
"*Hinweis: Laden Sie das digitalisierte Stapeldiagramm zusammen mit diesem Notebook in Moodle hoch. Wenn Sie wollen, können Sie auch ASCII-Textboxen direkt hier einfügen, ungefähr so:*\n",
"\n",
"```\n",
" +----------------------------------------+\n",
"__main__ | teil1 -> 'Holleri du dödel di ' |\n",
" | teil2 -> 'diri diri dudel dö' |\n",
" +----------------------------------------+\n",
"\n",
"```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Aufgabe 3\n",
"\n",
"*(Das ist [Aufgabe 4 im 6. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar06.ipynb#aufgabe-4).)*\n",
"\n",
"Eine ganze Zahl `a` ist eine Potenz von `b`, wenn `a` durch `b` teilbar ist und `a/b` eine Potenz von `b` ist. (Beispielsweise ist 27 eine Potenz von 3, denn 27 ist durch 3 teilbar und 9 ist eine Potenz von 3.) Schreiben Sie eine Funktion `is_power` die Parameter `a` und `b` erwartet und `True` zurückgibt, wenn `a` eine Potenz von `b` ist (ansonsten `False`). Hinweis: Überlegen Sie sich, was der Basisfall ist und wie Sie diesen behandeln.\n",
"\n",
"*Falls Sie die Lösung aus der Übung übernehmen, schreiben Sie Kommentare, die zeigen, dass Sie den Code und die Rekursion verstanden haben. Ansonsten wird die Aufgabe nicht gewertet.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
" # Implementieren Sie hier ihre Funktion\n",
"\n",
" "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Rufen Sie hier ihre Funktionen auf, um sie zu testen"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Aufgabe 4\n",
"\n",
"Ziel dieser Aufgabe ist, eine ASCII-Tabelle für die Zeichen mit dem Code von 32 (dezimal) bis 127 (dezimal) mit den zugehören Hexadezimalcodes auszugeben. Das Ergebnis sollte so aussehen:\n",
"\n",
"```\n",
"20 21 ! 22 \" 23 # 24 $ 25 % 26 & 27 ' 28 ( 29 ) 2a * 2b + 2c , 2d - 2e . 2f / \n",
"30 0 31 1 32 2 33 3 34 4 35 5 36 6 37 7 38 8 39 9 3a : 3b ; 3c < 3d = 3e > 3f ? \n",
"40 @ 41 A 42 B 43 C 44 D 45 E 46 F 47 G 48 H 49 I 4a J 4b K 4c L 4d M 4e N 4f O \n",
"50 P 51 Q 52 R 53 S 54 T 55 U 56 V 57 W 58 X 59 Y 5a Z 5b [ 5c \\ 5d ] 5e ^ 5f _ \n",
"60 ` 61 a 62 b 63 c 64 d 65 e 66 f 67 g 68 h 69 i 6a j 6b k 6c l 6d m 6e n 6f o \n",
"70 p 71 q 72 r 73 s 74 t 75 u 76 v 77 w 78 x 79 y 7a z 7b { 7c | 7d } 7e ~ \n",
"```\n",
"\n",
"Lesen Sie sich den Exkurs am Anfang des [5. Kapitels](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar05.ipynb) durch und versuchen Sie zu verstehen, wie die Funktion `dez_zu_allem` funktioniert. Dazu sollte es reichen, die Funktion mit verschiedenen Eingaben aufzurufen und zu verstehen, wie die jeweilige Ausgabe mit der Eingabe zusammenhängt. (Der Parameter `s` stellt das Alphabet für ein Positionssystem dar, wobei alle Zeichen einfach hintereinander als Zeichenkette erwartet werden.) \n",
"\n",
"Kopieren Sie sich die Funktion `dez_zu_allem` hierher und rufen Sie sie mit dem Dezimalcode für das Zeichen 'B' auf (diesen finden Sie in der ASCII-Tabelle aus der Vorlesung), so dass der Wert als Hexadezimalzahl zurückgegeben wird. Geben Sie diese Hexadezimalzahl mit `print` aus. (Es sollte '42' ausgegeben werden.)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Fügen Sie hier dez_zu_allem sowie Ihren Testcode ein"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mit der Funktion `chr` können wir Dezimalzahlen zwischen 0 und 127 in das entsprechende ASCII-Zeichen (als Zeichenkette) umwandeln. Probieren Sie es aus, indem Sie mit Hilfe von `chr` das Zeichen mit dem (dezimalen) ASCII-Code 84 ausgeben. (Es sollte `T` ausgegeben werden.)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Fügen Sie hier Ihren Code ein\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Schreiben Sie jetzt eine Funktion `zeichentabelle`, die folgende Parameter erwartet:\n",
"- `anfang`: die Dezimalzahl des ASCII-Codes des ersten Zeichens, welches ausgegeben werden soll\n",
"- `ende`: die Dezimalzahl des ASCII-Codes des letzten Zeichens, welches ausgegeben werden soll\n",
"- `trennzeichen`: eine Zeichenkette, die als Trennzeichen zwischen zwei Code-Zeichen-Paaren ausgegeben werden soll\n",
"- `paare_pro_zeile`: die Anzahl an Code-Zeichen-Paaren die pro Zeile ausgegeben werden sollen\n",
"\n",
"Die Funktion soll mit Hilfe einer `for`-Schleife und der `range`-Funktion über alle Dezimalzahlen zwischen `anfang` und `ende` (jeweils inklusive) laufen und den Hexadezimalcode sowie das zugehörige Zeichen durch Leerzeichen getrennt ausgeben. Danach soll das `trennzeichen` ausgegeben werden und nach entsprechend vielen Paaren soll eine neue Zeile erzeugt werden. \n",
"\n",
"Hinweis: Sie können bei der `print`-Funktion die Ausgabe eines Zeilenumbruchs unterdrücken, indem Sie dem Parameter `end` einen anderen Wert mitgeben, beispielsweise so:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(\"Spalte 1\", end=\" | \")\n",
"print(\"Spalte 2\", end=\" | \")\n",
"print(\"Spalte 3\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Implementieren Sie hier die Funktion \n",
"def zeichentabelle():\n",
" \"\"\"...\"\"\"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Testaufruf, der die Tabelle oben erzeugen sollte\n",
"zeichentabelle(32, 127, \" \", 16)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hier folgen weitere Tipps ... versuchen Sie es aber erst einmal ohne diese Tipps.\n",
"\n",
"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
"\n",
"Der Restoperator `%` kann Ihnen helfen, im richtigen Rhythmus Zeilenumbrüche einzufügen. \n",
"\n",
"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
"\n",
"Sie müssen den Rest der aktuellen Zahl bei Division durch `paare_pro_zeile` prüfen. \n",
"\n",
"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
"\n",
"Es ist etwas knifflig, die Zeilen mit dem richtigen Wert beginnen zu lassen (im Beispiel `20`, `30`, `40`). Das ist ganz normal und sie müssen etwas probieren, um das zu schaffen.\n",
"\n",
"<a data-flickr-embed=\"true\" href=\"https://www.flickr.com/photos/jasoneppink/4964471335\" title=\"Spoiler Alert\"><img src=\"https://farm5.staticflickr.com/4110/4964471335_1f86a923f3_n.jpg\" width=\"320\" height=\"213\" alt=\"Spoiler Alert\"></a><script async src=\"//embedr.flickr.com/assets/client-code.js\" charset=\"utf-8\"></script>\n",
"\n",
"Probieren Sie verschiedene Werte für den Rest durch, dann sollte es klappen.\n",
"\n",
"Da Python Unicode unterstützt können mit der `chr`-Funktion alle Zeichen aus dem Unicode-Vorrat ausgegeben werden. Probieren Sie es einmal mit Zahlen größer als 127 aus:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"print(chr(2000))\n",
"print(chr(4000))\n",
"print(chr(8000))\n",
"print(chr(16000))\n",
"print(chr(32000))\n",
"print(chr(64000))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"*(Nicht alle Zahlenwerte funktionieren, nur diejenigen, die auch im Unicode definiert sind.)*\n",
"\n",
"Finden Sie den Dezimalwert (!) für das Zeichen `ä` im Unicode (nicht UTF-8) und geben Sie dieses mittels `chr` aus. Es kann sein, dass Sie nur den Hexadezimalwert finden - diesen müssten sie dann zunächst in einen Dezimalwert umrechnen, z.B. auf [dieser Webseite](http://www.binaryhexconverter.com/hex-to-decimal-converter)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Und wenn Sie bis hierher gekommen sind: geben Sie eine Tabelle von Zeichen aus einem anderen Schriftsystem Ihrer Wahl aus, indem Sie Ihre Funktion `zeichentabelle` mit anderen Start- und Endwerten aufrufen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Aufgabe 5 (Zusatz):\n",
"\n",
"Nutzen Sie Rekursion (falls nicht schon in Hausaufgabe2 benutzt), um Ihre Schildkröte ein Kunstwerk malen zu lassen. Schauen Sie in Notebook 5 nach, um sich inspirieren zu lassen.\n",
"\n",
"Diese Aufgabe ist freiwillig. \n",
"\n",
"Sie können gerne wieder kreativ werden."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
""
]
}
],
"metadata": {
"language_info": {
"name": "python",
"pygments_lexer": "ipython3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}