"*(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 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."
"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."
]
},
{
...
...
%% Cell type:markdown id: tags:
# 3. Hausaufgabe
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.
Wir wünschen viel Erfolg beim Lösen der Aufgaben!
%% Cell type:markdown id: tags:
## Aufgabe 1
*(Dies ist [Aufgabe 3 im 5. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar05.ipynb#aufgabe-3).)*
Wenn uns drei Stöcke gegeben werden, kann es sein, dass wir sie als Dreieck anordnen können oder auch nicht. Wenn beispielsweise einer der Stöcke 12cm lang ist und die anderen beiden jeweils 1cm, dann klappt es nicht. Für jede Kombination von Längen gibt es einen einfachen Test, der uns anzeigt, ob sich daraus ein Dreieck formen lässt:
*Falls eine der drei Längen größer als die Summe der anderen beiden Längen ist, dann lässt sich kein Dreieck formen. (Wenn die Summe der beiden Längen gleich der dritten Länge ist, dann bilden Sie ein sogenanntes "degeneriertes" Dreieck.)*
1. Schreiben Sie eine Funktion `is_triangle` die drei ganze Zahlen als Argumente erwartet und dann entweder "Ja" oder "Nein" ausgibt, abhängig davon, ob man mit den gegebenen Längen ein Dreieck formen kann oder nicht.
2. Schreiben Sie eine Funktion die die Nutzerin bittet, drei Längen einzugeben, diese in ganze Zahlen umwandelt und dann `is_triangle` nutzt, um zu prüfen, ob aus Stöcken mit den gegebenen Längen ein Dreieck geformt werden kann oder nicht.
%% Cell type:code id: tags:
```
# Implementieren und testen Sie hier die beiden Funktionen
```
%% Cell type:markdown id: tags:
## Aufgabe 2
*(Dies ist [Aufgabe 4 im 5. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar05.ipynb#aufgabe-4).)*
Was gibt das folgende Programm aus? Zeichnen Sie (mit Stift und Papier) 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 id: tags:
```
def recurse(n, s):
if n == 0:
print(s)
else:
recurse(n-1, n+s)
recurse(3, 0)
```
%% Cell type:markdown id: tags:
1. Was würde passieren, wenn wir diese Funktion so aufrufen würden: `recurse(-1, 0)`?
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!).
*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:*
```
+----------------------------------------+
__main__ | teil1 -> 'Holleri du dödel di ' |
| teil2 -> 'diri diri dudel dö' |
+----------------------------------------+
```
%% Cell type:markdown id: tags:
## Aufgabe 3
*(Das ist [Aufgabe 4 im 6. Kapitel](https://scm.cms.hu-berlin.de/ibi/python/blob/master/notebooks/seminar06.ipynb#aufgabe-4).)*
Eine 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.
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.
%% Cell type:code id: tags:
```
# Implementieren und testen Sie hier ihre Funktion
```
%% Cell type:markdown id: tags:
## Aufgabe 4
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:
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
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 _
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
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 ~
```
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.)
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 id: tags:
```
# Fügen Sie hier dez_zu_allem sowie Ihren Testcode ein
```
%% Cell type:markdown id: tags:
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 id: tags:
```
# Fügen Sie hier Ihren Code ein
```
%% Cell type:markdown id: tags:
Schreiben Sie jetzt eine Funktion `zeichentabelle`, die folgende Parameter erwartet:
-`anfang`: die Dezimalzahl des ASCII-Codes des ersten Zeichens, welches ausgegeben werden soll
-`ende`: die Dezimalzahl des ASCII-Codes des letzten Zeichens, welches ausgegeben werden soll
-`trennzeichen`: eine Zeichenkette, die als Trennzeichen zwischen zwei Code-Zeichen-Paaren ausgegeben werden soll
-`paare_pro_zeile`: die Anzahl an Code-Zeichen-Paaren die pro Zeile ausgegeben werden sollen
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.
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 id: tags:
```
print("Spalte 1", end=" | ")
print("Spalte 2", end=" | ")
print("Spalte 3")
```
%% Cell type:code id: tags:
```
# Implementieren Sie hier die Funktion
def zeichentabelle ...
# Testaufruf, der die Tabelle oben erzeugen sollte
zeichentabelle(32, 127, " ", 16)
```
%% Cell type:markdown id: tags:
Hier folgen weitere Tipps ... versuchen Sie es aber erst einmal ohne diese Tipps.
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.
Probieren Sie verschiedene Werte für den Rest durch, dann sollte es klappen.
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 id: tags:
```
print(chr(2000))
print(chr(4000))
print(chr(8000))
print(chr(16000))
print(chr(32000))
print(chr(64000))
```
%% Cell type:markdown id: tags:
*(Nicht alle Zahlenwerte funktionieren, nur diejenigen, die auch im Unicode definiert sind.)*
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 id: tags:
```
chr(228)
```
%% Cell type:markdown id: tags:
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 größeren Start- und Endwerten aufrufen:
