diff --git a/notebooks/FAQ.ipynb b/notebooks/FAQ.ipynb
index 678d13fc033776824509181f658ac27372e9ab72..4aaa032294986d4b3dbdba59b64bca49299a7678 100644
--- a/notebooks/FAQ.ipynb
+++ b/notebooks/FAQ.ipynb
@@ -469,6 +469,27 @@
"turtle.bye()"
]
},
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Diese Funktion können wir nutzen, um unsere Schildkröte mit zufälligen Farben zu färben. \n",
+ "# Wir können die Funktion nutzen, indem wir sie in unseren Codeblock einfügen und dann an passender Stelle aufrufen.\n",
+ "# Im nächsten Codeblock ist ein Beispiel gegeben. \n",
+ "# Varianten: setcolor(t,1) : Schildkröte und Zeichnung in derselben zufälligen Farbe\n",
+ "# Varianten: setcolor(t,2) : Schildkröte und Zeichnung in zwei unterschiedlichen zufälligen Farben\n",
+ "from random import randint\n",
+ "def setcolor(t,n):\n",
+ " turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren\n",
+ " if n==1: \n",
+ " t.color(randint(0,255),randint(0,255),randint(0,255)) #generiert eine zufällige Farbe für die turtle\n",
+ " if n==2: \n",
+ " t.color((randint(0,255),randint(0,255),randint(0,255)),(randint(0,255),randint(0,255),randint(0,255))) #generiert eine zufällige Farbe für die turtle\n",
+ " \n"
+ ]
+ },
{
"cell_type": "code",
"execution_count": null,
@@ -476,6 +497,7 @@
"outputs": [],
"source": [
"import turtle\n",
+ "from random import randint\n",
"\n",
"otto=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen otto zugewiesen\n",
"anna=turtle.Turtle() # definiert ein turtle-Objekt, wird der Variablen anna zugewiesen\n",
@@ -483,21 +505,31 @@
"\n",
"#Hier lernen wir die Funktionen shape(), stamp(), color(), colormode() und fd() kennen\n",
"\n",
- "colors=['red','purple','blue','yellow','orange']\n",
- "def line(t): \n",
+ "# Fkt setcolor wurde hier eingefügt\n",
+ "def setcolor(t,n):\n",
+ " turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren\n",
+ " if n==1: \n",
+ " t.color(randint(0,255),randint(0,255),randint(0,255)) #generiert eine zufällige Farbe für die turtle\n",
+ " if n==2: \n",
+ " t.color((randint(0,255),randint(0,255),randint(0,255)),(randint(0,255),randint(0,255),randint(0,255))) #generiert eine zufällige Farbe für die turtle\n",
+ "\n",
+ " \n",
+ "def line(t): #Diese Funktion malt eine einfache Linie (in verschiedenen Farben und mit Stempeln jede 100 Einheiten)\n",
+ " setcolor(t,1) #Hier rufen wir setcolor mit unserer turtle auf und setzen n=1, um die Linie und die Schildkröte in derselben Farbe zu färben\n",
" t.shape('turtle')\n",
" t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
" t.fd(100)\n",
- " turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren\n",
- " t.color(255,180,200) #Jetzt können wir Farben in RGB-Werten angeben (--> mehr Möglichkeiten)\n",
+ " setcolor(t,1) #nächster Aufruf von setcolor\n",
+ " setcolor(t,1) # wir können setcolor beliebig oft und an beliebiger Stelle aufrufen\n",
" t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
" t.fd(100)\n",
- " t.color(colors[1])\n",
+ " setcolor(t,2)\n",
" t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
" t.fd(100)\n",
- " t.color(colors[4])\n",
+ " setcolor(t,2)\n",
" t.stamp() #wir machen einen Stempel an dieser Stelle von unserem turtle\n",
" t.fd(100)\n",
+ " setcolor(t,2)\n",
"\n",
" \n",
"line(telmo) #wir rufen line mit der turtle namens telmo auf. Wir könnten aber genauso anna oder otto nehmen\n",
diff --git a/notebooks/hausaufgabe1.ipynb b/notebooks/hausaufgabe1.ipynb
index 239d07e3a08530e06435f4512628cf1532ce87ca..763ebd60b917f07695cd3add6ba990b6532654df 100644
--- a/notebooks/hausaufgabe1.ipynb
+++ b/notebooks/hausaufgabe1.ipynb
@@ -80,7 +80,7 @@
"outputs": [],
"source": [
"# Implementieren Sie hier ihre Funktion\n",
- "\n",
+ " \n",
"# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu\n",
"boxprint(\"Hello World!\")\n",
"boxprint(\"Dieser Text muss auch in die Box passen.\")"
diff --git a/notebooks/hausaufgabe2.ipynb b/notebooks/hausaufgabe2.ipynb
index 6718968de4b8b5f82eed629e0c78cf3964128527..34ed630d457d684cec72861659d630a42683b0c0 100644
--- a/notebooks/hausaufgabe2.ipynb
+++ b/notebooks/hausaufgabe2.ipynb
@@ -60,7 +60,7 @@
"\n",
"\n",
" - **Aufgabe 1:** Schreiben Sie eine Funktion `triangle`, die zwei Parameter `t` und `l` erwartet. `t` ist eine Schildkröte, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um ein gleichseitiges Dreieck mit Seitenlänge `l` zu zeichnen. \n",
- " - **Aufgabe 2:** Schreiben Sie einen Funktionsaufruf, der `bob` als Argument an `square` übergibt und rufen Sie ihr Programm auf."
+ " - **Aufgabe 2:** Schreiben Sie einen Funktionsaufruf, der `otto` und `40` an `triangle` übergibt und rufen Sie ihr Programm auf."
]
},
{
@@ -87,34 +87,59 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "- **Aufgabe 3:** Nutzen Sie die folgenden Funktionen, um die Schildkröte in einer Farbe Ihrer Wahl zu färben."
+ "### Hilfsfunktion:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#Wenn Sie diese Funktion mit Ihrer turtle aufrufen, wird die turtle eine zufällige Farbe annehmen \n",
+ "from random import randint #zuerst müssen wir uns die Methode randint aus der Bibliothek \"random\" importieren\n",
+ "def setcolor(t,n): \n",
+ " turtle.colormode(255) # um RGB-Farben anzuwenden, muss man vorher diesen Colormode aktivieren\n",
+ " if n==1: #setze n=1, um die Schildkröte und Formen in der gleichen Farbe zu färben\n",
+ " t.color(randint(0,255),randint(0,255),randint(0,255)) #generiert eine zufällige Farbe für die turtle\n",
+ " if n==2: # setze n=2, um Schildkröte und Formen in unterschiedlichen Farben zu färben\n",
+ " t.color((randint(0,255),randint(0,255),randint(0,255)),(randint(0,255),randint(0,255),randint(0,255))) \n",
+ " \n",
+ "'''Diese Funktion kann genutzt werden, um Ihrer turtle zufällige Farben zu geben. Für mehr Infos, schauen Sie in das FAQ. Dort sind Beispiele implementiert.'''"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "- **Aufgabe 4:** Nutzen Sie die folgenden Funktionen, um Ihr Dreieck in einer Farbe Ihrer Wahl zu färben."
+ "### eingebaute turtle-Methoden:\n",
+ "- Dokumention von python: https://docs.python.org/3/library/turtle.html\n",
+ " - Dort finden Sie alle Funktionen, die Sie auf Ihre Schildkröte anwenden können. Wichtig für die Hausaufgabe sind (neben denen, die Sie schon kennengelernt haben):\n",
+ "- `t.shape('turtle')`: ändert die Gestalt der \"Schildkröte\" in eine Schildkröte.\n",
+ "- Die Farbe der Schildkröte und der Färbung der Muster wählt man mit `t.color(c)`, wobei `c` eine Zeichenkette ist (z.B. 'red', 'green', etc.) \n",
+ "- `t.begin_fill()` ... `t.end_fill()`: Färbt das Muster, was die Schildkröte zwischen den beiden Anweisungen gezeichnet hat, ein.\n",
+ "- `t.stamp()`: Platziert bei Aufruf eine Schildkröte an der Stelle, an der die Schildkröte sich zu diesem Zeitpunkt befindet."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "- **Aufgabe 5:** Nutzen Sie die folgenden Funktionen, um an jeder Ecke Ihres Dreiecks eine Schildkröte zu platzieren."
+ "- **Aufgabe 3:** Nutzen Sie die Funktionen, um die Schildkröte in einer Farbe Ihrer Wahl zu färben. Dies können Sie direkt in Ihrem Code aus Aufgabe 2 einbauen. Sie können aber auch einen neuen Codeblock erstellen."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "### turtle-Methoden:\n",
- "- Dokumention von python: https://docs.python.org/3/library/turtle.html\n",
- " - Dort finden Sie alle Funktionen, die Sie auf Ihre Schildkröte anwenden können. Wichtig für die Hausaufgabe sind (neben denen, die Sie schon kennengelernt haben):\n",
- "- `t.shape('turtle')`: ändert die Gestalt der \"Schildkröte\" in eine Schildkröte.\n",
- "- Die Farbe der Schildkröte und der Färbung der Muster wählt man mit `t.color(c)`, wobei `c` eine Zeichenkette ist (z.B. 'red', 'green', etc.) \n",
- "- `t.begin_fill()` ... `t.end_fill()`: Färbt das Muster, was die Schildkröte zwischen den beiden Anweisungen gezeichnet hat, ein.\n",
- "- `t.stamp()`: Platziert bei Aufruf eine Schildkröte an der Stelle, an der die Schildkröte sich zu diesem Zeitpunkt befindet."
+ "- **Aufgabe 4:** Nutzen Sie die Funktionen, um Ihr Dreieck in einer Farbe Ihrer Wahl zu färben. Dies können Sie direkt in Ihrem Code aus Aufgabe 2 einbauen. Sie können aber auch einen neuen Codeblock erstellen."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "- **Aufgabe 5:** Nutzen Sie die Funktionen, um an jeder Ecke Ihres Dreiecks eine Schildkröte zu platzieren. Dies können Sie direkt in Ihrem Code aus Aufgabe 2 einbauen. Sie können aber auch einen neuen Codeblock erstellen."
]
},
{
@@ -126,7 +151,7 @@
" - *Zusatz*: Verändern Sie die Funktion so, dass sie eine variable Anzahl von Dreiecken zeichnen kann, die als Argument übergeben wird.\n",
"\n",
"- Eine mögliche Lösung könnte so aussehen:\n",
- ""
+ ""
]
},
{
@@ -142,7 +167,7 @@
"\n",
"# Testen Sie hier ihre Funktion; fügen Sie auch eigene Tests hinzu\n",
"otto = turtle.Turtle()\n",
- "repeat_triangle(otto, 40)\n",
+ "repeat_triangle(otto, 80)\n",
"\n",
"turtle.mainloop()\n",
"turtle.bye()"
@@ -154,10 +179,11 @@
"source": [
"- **Aufgabe 7:** Schreiben Sie eine Funktion `pile_triangle`, die **vier Dreiecke übereinander** zeichnet. Sie soll zwei Argumente `t` und `l` erhalten. `t` ist eine Schildkröte, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um die gleichseitigen Dreiecke mit Seitenlänge `l` zu zeichnen. Die Farbe der Dreiecke soll nicht schwarz sein. <br>\n",
" - *Zusatz* : Jedes Dreieck soll eine eigene Farbe haben.\n",
+ " - *Zusatz*: Verändern Sie die Funktion so, dass sie eine variable Anzahl von Dreiecken zeichnen kann, die als Argument übergeben wird.\n",
"\n",
"\n",
"- Eine mögliche Lösung könnte so aussehen: \n",
- ""
+ ""
]
},
{
@@ -188,10 +214,11 @@
"source": [
"- **Aufgabe 8:** Schreiben Sie eine Funktion `tiled_triangle`, die **drei Dreiecke übereinander und drei Dreiecke nebeneinander** zeichnet. Sie soll zwei Argumente `t` und `l` erhalten. `t` ist eine Schildkröte, `l` eine Ganzzahl. Die Funktion soll die Schildkröte nutzen, um die gleichseitigen Dreiecke mit Seitenlänge `l` zu zeichnen. Die Farbe der Dreiecke soll nicht schwarz sein. <br>\n",
" - *Zusatz* : Jedes Dreieck soll eine eigene Farbe haben.\n",
+ " - *Für Profis* : Färben Sie auch die Zwischenräume, die hier entstehen\n",
" \n",
"\n",
"- Eine mögliche Lösung könnte so aussehen:\n",
- ""
+ ""
]
},
{
diff --git a/notebooks/seminar05.ipynb b/notebooks/seminar05.ipynb
index 501ebcd3786e2d89a2a89d3cfb83a00d9c90140e..1a4eb1931a48f085ff02f39fa57103448e228340 100644
--- a/notebooks/seminar05.ipynb
+++ b/notebooks/seminar05.ipynb
@@ -13,6 +13,11 @@
"source": [
"# Seminar Problemorientierte Programmierung\n",
"\n",
+ "## 5 Verzweigungen und Rekursion\n",
+ "\n",
+ "Das erste Thema dieses Kapitels ist die `if`-Anweisung, die unterschiedlichen Code ausführt, je nach Zustand des Programms. Im zweiten Teil lernen Sie die `Rekursion` kennen.\n",
+ "\n",
+ "(Buch: http://greenteapress.com/thinkpython2/html/thinkpython2006.html)\n",
"## Exkurs: Was mir an Python gefällt\n",
"\n",
"In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.\n",
@@ -61,15 +66,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "## 5 Verzweigungen und Rekursion\n",
- "\n",
- "Das Thema dieses Kapitels ist die `if`-Anweisung, die unterschiedlichen Code ausführt, je nach Zustand des Programms. Aber schauen wir uns zunächst zwei neue Operatoren an: Ganzzahldivision und Restberechnung.\n",
- "\n",
"### 5.1 Ganzzahldivision und Restberechnung\n",
"\n",
"Der Operator `//` für die **Ganzzahldivision** teilt zwei ganze Zahlen und rundet das Ergebnis zu einer ganzen Zahl ab. \n",
"\n",
- "Angenommen, wir wollen wissen, wie lang ein Film über 105 Minuten in Stunden ist. Bei der üblichen Division erhalten wir eine Gleitkommazahl: "
+ "Angenommen, wir wollen wissen, wie lang ein Film über 105 Minuten in Stunden dauert. Bei der üblichen Division erhalten wir eine Gleitkommazahl: "
]
},
{
@@ -245,7 +246,7 @@
"x <= y # x ist kleiner oder gleich y\n",
"```\n",
"\n",
- "Auch wenn Ihnen diese Symbole wahrscheinlich bekannt vorkommen, so sind sie doch anders als ihre mathematischen Äquivalente. Ein üblicher Fehler ist, das einfache Gleichheitszeichen (`=`) statt des doppelten Gleichheitszeichens (`==`) zu verwenden. Wir merken uns: `=` ist der Zuweisungsoperator und `==` ist ein relationaler Operator. Die Operatoren `=<` und `=>` gibt es nicht.\n",
+ "Auch wenn Ihnen diese Symbole wahrscheinlich bekannt vorkommen, so sind sie doch anders als ihre mathematischen Äquivalente. **Ein üblicher Fehler ist, das einfache Gleichheitszeichen (`=`) statt des doppelten Gleichheitszeichens (`==`) zu verwenden.** Wir merken uns: `=` ist der Zuweisungsoperator und `==` ist ein relationaler Operator. Die Operatoren `=<` und `=>` gibt es nicht.\n",
"\n",
"\n",
"\n",
@@ -260,7 +261,7 @@
"\n",
"Es gibt drei **logische Operatoren**: `and`, `or` und `not`. Die Semantik (Bedeutung) dieser drei Operatoren ist ähnlich der Bedeutung der englischen Wörter. Beispielsweise ist `x > 0 and x < 10` genau dann wahr, wenn `x` größer als 0 *und* kleiner als 10 ist.\n",
"\n",
- "`n%2 == 0 or n%3 == 0` ist wahr wenn *eine oder beide* der Bedingungen wahr ist, das heißt wenn die Zahl `n` durch 2 *oder* drei teilbar ist.\n",
+ "`n%2 == 0 or n%3 == 0` ist wahr, wenn *eine oder beide* der Bedingungen wahr ist, das heißt wenn die Zahl `n` durch 2 *oder* drei teilbar ist.\n",
"\n",
"Genaugenommen sollten die Operanden der logischen Operatoren Boolesche Ausdrücke sein, aber Python erlaubt uns da mehr Freiheit. Jede Zahl ungleich Null wird als `True` interpretiert:"
]
@@ -323,9 +324,9 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "`if`-Anweisungen haben die gleiche Struktur wie Funktionsdefinitionen: ein (Verzweigungs-)Kopf gefolgt von einem eingerückten (Verzweigungs-)Rumpf. Anweisungen dieser Art werden **Verbundanweisungen** genannt. \n",
+ "`if`-Anweisungen haben die gleiche Struktur wie Funktionsdefinitionen: ein (Verzweigungs-)Kopf, gefolgt von einem eingerückten (Verzweigungs-)Rumpf. Anweisungen dieser Art werden **Verbundanweisungen** genannt. \n",
"\n",
- "Die Anzahl an Anweisungen, die im Rumpf stehen können ist nicht begrenzt, aber es muss mindestens eine Anweisung sein. Manchmal ist es nützlich, einen Rumpf ohne Anweisungen zu haben (üblicherweise als Platzhalter für Code, den wir noch schreiben wollen). In diesem Fall können wir die **`pass`**-Anweisung verwenden, die nichts tut:"
+ "Die Anzahl an Anweisungen, die im Rumpf stehen können, ist nicht begrenzt, aber es muss mindestens eine Anweisung sein. Manchmal ist es nützlich, einen Rumpf ohne Anweisungen zu haben (üblicherweise als Platzhalter für Code, den wir noch schreiben wollen). In diesem Fall können wir die **`pass`**-Anweisung verwenden, die nichts tut:"
]
},
{
@@ -344,7 +345,7 @@
"source": [
"### 5.5 Alternative Verzweigung\n",
"\n",
- "Eine zweite Form der `if`-Anweisung ist die \"alternative Verzweigung\", bei der es zwei Möglichkeiten gibt und die Bedingung festglegt, welche davon ausgeführt wird. Die Syntax ist folgendermaßen:"
+ "Eine zweite Form der `if`-Anweisung ist die \"alternative Verzweigung\", bei der es zwei Möglichkeiten gibt und die Bedingung festlegt, welche davon ausgeführt wird. Die Syntax sieht folgendermaßen aus:"
]
},
{
@@ -372,7 +373,7 @@
"source": [
"### 5.6 Verkettete Verzweigungen\n",
"\n",
- "Manchmal gibt es mehr als zwei Möglichkeiten und wir benötigen mehr als zwei Zweige. Eine Möglichkeit eine Berechnung dieser Art auszudrücken sind sogenannte **verkettete Verzweigungen**:"
+ "Manchmal gibt es mehr als zwei Möglichkeiten und wir benötigen mehr als zwei Zweige. Eine Möglichkeit eine Berechnung dieser Art auszudrücken, sind sogenannte **verkettete Verzweigungen**:"
]
},
{
@@ -404,7 +405,7 @@
" draw_c()\n",
"```\n",
"\n",
- "Jede Bedingung wird in der vorgegebenen Reihenfolge geprüft. Wenn die erste nicht erfüllt (falsch) ist, wird die nächste geprüft, und so weiter. Sobald eine der Bedingungen erfüllt (wahr) ist, wird der entsprechende Zweig ausgeführt und die `if`-Anweisung wird beendet. Auch wenn mehr als eine Bedingung erfüllt ist, wird nur der erste zutreffende Zweig ausgeführt."
+ "Jede Bedingung wird in der vorgegebenen Reihenfolge geprüft. Wenn die erste nicht erfüllt (falsch) ist, wird die nächste geprüft, und so weiter. Sobald eine der Bedingungen erfüllt (wahr) ist, wird der entsprechende Zweig ausgeführt und die `if`-Anweisung wird beendet. **Auch wenn mehr als eine Bedingung erfüllt ist, wird nur der erste zutreffende Zweig ausgeführt.**"
]
},
{
@@ -551,7 +552,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Wenn `n` Null ist oder negativ, gibt die Funktion \"Abheben!\" aus. Ansonsten wird `n` ausgegeben und eine Funktion `countdown` - die Funktion selbst - aufgerufen mit `n-1` als Argument. \n",
+ "Wenn `n` Null oder negativ ist, gibt die Funktion \"Abheben!\" aus. Ansonsten wird `n` ausgegeben und eine Funktion `countdown` - die Funktion selbst - aufgerufen mit `n-1` als Argument. \n",
"\n",
"Was passiert wenn wir diese Funktion folgendermaßen aufrufen?"
]
@@ -591,7 +592,9 @@
"\n",
"Eine Funktion die sich selbst aufruft wird **rekursiv** genannt; der Vorgang wird **Rekursion** genannt.\n",
"\n",
- "Als weiteres Beispiel schreiben wir eine Funktion die eine Zeichenkette `n` mal ausgibt:"
+ "**Es ist wichtig, dass Sie dieses Beispiel verstanden haben. Falls das nicht der Fall sein sollte, lassen Sie es sich von Ihrem Partner, Kommilitonen oder Übungsleiter erklären.**\n",
+ "\n",
+ "Als weiteres Beispiel schreiben wir eine Funktion, die eine Zeichenkette `n` mal ausgibt:"
]
},
{
@@ -626,7 +629,7 @@
"\n",
"In [Abschnitt 3.9](seminar03.ipynb#3.9-Stapel-Diagramme) haben wir Stapeldiagramme genutzt, um den Zustand eines Programms während eines Funktionsaufrufs zu repräsentieren. Die gleiche Art Diagramm kann uns helfen, eine rekursive Funktion zu interpretieren.\n",
"\n",
- "Jedes Mal wenn eine Funktion aufgerufen wird, erstellt Python einen Block der die lokalen Variablen und Parameter der Funktion enthält. Für eine rekursive Funktion kann es zur gleichen Zeit mehrere Blöcke auf dem Stapel geben.\n",
+ "Jedes Mal, wenn eine Funktion aufgerufen wird, erstellt Python einen Block, der die lokalen Variablen und Parameter der Funktion enthält. Für eine rekursive Funktion kann es zur gleichen Zeit mehrere Blöcke auf dem Stapel geben.\n",
"\n",
"Die folgende Abbildung zeigt ein Stapeldiagramm für den Aufruf von `countdown(3)`:\n",
"\n",
@@ -726,7 +729,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Bevor man von der Nutzerin eine Eingabe bekommt, ist es eine gute Idee, einen Hinweis auszugeben der der Nutzerin sagt, was Sie eintippen soll. Der Funktion `input` können wir einen solchen Hinweis als Argument übergeben: "
+ "Bevor man von der Nutzerin eine Eingabe bekommt, ist es eine gute Idee, einen Hinweis auszugeben, der der Nutzerin sagt, was Sie eintippen soll. Der Funktion `input` können wir einen solchen Hinweis als Argument übergeben: "
]
},
{
@@ -942,8 +945,8 @@
"\\end{equation}\n",
"für alle $n$ größer 2 gilt.\n",
"\n",
- "1. Schreiben Sie eine Funktion `check_fermat` die vier Parameter erwartet - `a`, `b`, `c` und `n` - und prüft, ob Fermats letzter Satz gilt Falls `n` größer als 2 ist und $a^n + b^n = c^n$ gilt, sollte das Programm \"Unglaublich, Fermat lag falsch!\" ausgeben, ansonsten \"Nein, das funktioniert nicht.\"\n",
- "2. Schreiben Sie eine Funktion, die den Nutzer bittet, Werte für a, b, c und n einzugeben, diese in ganze Zahlen umwandelt und dann die Funktion `check_fermat` nutzt um zu prüfen, ob sie Fermats letzten Satz erfüllen. "
+ "1. Schreiben Sie eine Funktion `check_fermat` die vier Parameter erwartet - `a`, `b`, `c` und `n` - und prüft, ob Fermats letzter Satz gilt. Falls `n` größer als 2 ist und $a^n + b^n = c^n$ gilt, sollte das Programm \"Unglaublich, Fermat lag falsch!\" ausgeben, ansonsten \"Nein, das funktioniert nicht.\"\n",
+ "2. Schreiben Sie eine Funktion, die den Nutzer bittet, Werte für a, b, c und n einzugeben, diese in ganze Zahlen umwandelt und dann die Funktion `check_fermat` nutzt, um zu prüfen, ob sie Fermats letzten Satz erfüllen. "
]
},
{
@@ -966,7 +969,7 @@
"*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.)*\n",
"\n",
"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.\n",
- "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."
+ "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."
]
},
{