From 8f50a7e93b929704bc25e7ae3b0c1c4b5ac50b06 Mon Sep 17 00:00:00 2001 From: Tristan Schulz Date: Mon, 30 Sep 2024 19:45:02 +0200 Subject: [PATCH] =?UTF-8?q?=C3=9CBUNG=20YUP=20DUP?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- exercises/Aufgabe2.tex | 211 ++++------------------------------------- exercises/Aufgabe3.tex | 133 +++++++------------------- 2 files changed, 52 insertions(+), 292 deletions(-) diff --git a/exercises/Aufgabe2.tex b/exercises/Aufgabe2.tex index c6ae5ab..38eea36 100644 --- a/exercises/Aufgabe2.tex +++ b/exercises/Aufgabe2.tex @@ -51,22 +51,22 @@ \end{solution} \end{subtask*} \begin{subtask*}[points=0]{Assignment} - Ergänzt im folgenden Listing die fehlenden Variablenzuweisungen, so dass keine Fehler auftreten und am Ende {\ttfamily variable7} zu {\ttfamily true}, {\ttfamily variable2} zu {\ttfamily 5} und {\ttfamily variable5} zu {\ttfamily \verb+"abc"+} auswertet. + Ergänzt im folgenden Listing die fehlenden Variablenzuweisungen, so dass keine Fehler auftreten und am Ende {\ttfamily variable7} zu {\ttfamily True}, {\ttfamily variable2} zu {\ttfamily 5} und {\ttfamily variable5} zu {\ttfamily \verb+"abc"+} auswertet. \begin{codeBlock}[]{minted language=python} - variable1 = // hier Zuweisung 1 einsetzen + variable1 = # hier Zuweisung 1 einsetzen variable2 = 3 - variable3 = // hier Zuweisung 2 einsetzen - variable2 += variable1 + variable3 = # hier Zuweisung 2 einsetzen + variable2 = variable2 + variable1 if variable3 > 5: variable2 = 0 else: variable2 *= variable3 - variable4 = // hier Zuweisung 3 einsetzen - variable5 = // hier Zuweisung 4 einsetzen - variable5 += variable4 - variable6 = // hier Zuweisung 5 einsetzen + variable4 = # hier Zuweisung 3 einsetzen + variable5 = # hier Zuweisung 4 einsetzen + variable5 = variable5 + variable4 + variable6 = # hier Zuweisung 5 einsetzen variable7 = variable6 > variable2 * 2 - variable5 += "c" + variable5 = variable5 + "c" print(variable7) print(variable2) print(variable5) @@ -90,19 +90,19 @@ \begin{subtask*}[points=0]{Operatoren} Es seien die folgenden Variablen deklariert und initialisiert: \begin{codeBlock}[]{title=\codeBlockTitle{asdf},minted language=python} - x : int = 6 - y : int = 7 - z : int = 0 - a : int = False + x: int = 6 + y: int = 7 + z: int = 0 + a: int = False \end{codeBlock} Welchen Wert enthält die Variable \pythoninline{b} jeweils nach Ausführung der folgenden Anweisungen? \begin{enumerate} - \item \pythoninline{b : bool = x > 5 || y < 7 && z != 0} - \item \pythoninline{b : bool = x * y != y * x && x / z == 0} - \item \pythoninline{b : bool = !(x == y) && z <= 0} - \item \pythoninline{b : bool = x >= 11 || x < 9 && !(y == 2) && x + y * z > 0 || a} - \item \pythoninline{b : bool = z != z || !a && x - y * z <= 0} - \item \pythoninline{b : bool = !a && z < y - x} + \item \pythoninline{b: bool = x > 5 or y < 7 and z != 0} + \item \pythoninline{b: bool = x * y != y * x and x / z == 0} + \item \pythoninline{b: bool = not (x == y) and z <= 0} + \item \pythoninline{b: bool = x >= 11 or x < 9 and not(y == 2) and x + y * z > 0 or a} + \item \pythoninline{b: bool = z != z or not a and x - y * z <= 0} + \item \pythoninline{b: bool = not a and z < y - x} \end{enumerate} \begin{solution} @@ -152,178 +152,5 @@ \end{codeBlock} \end{solution} \end{subtask*} - \begin{subtask*}[points=0]{Taschenrechner} - In dieser Aufgabe soll ein sehr einfacher Taschenrechner implementiert werden, wobei wir uns dabei auf die Grundrechenarten beschränken wollen. Euer Programm soll nacheinander drei Eingaben entgegennehmen, zwei Operanden (\textbf{ganze Zahlen}) und einen Operator ({\ttfamily +, -, *, /}). Schließlich soll der Taschenrechner eine Ausgabe mit dem entsprechenden Ergebnis liefern. Vergesst nicht, euer Programm zu testen. - - \begin{solution} - \begin{codeBlock}[]{minted language=python} - op1 : int = int(input("Wie lautet der erste Operand: ")) - op2 : int = int(input("Wie lautet der zweite Operand: ")) - - op : str = input("Wie lautet der Operator: ") - - ergebnis : 0 = 0 - ergebnisOk : bool = True - - if op == "+": - ergebnis = op1 + op2 - elif op == "-": - ergebnis = op1 - op2 - elif op == "*": - ergebnis = op1 * op2 - elif op == "/": - if op2 == 0: - ergebnisOk = False - print("Division durch 0 ist nicht erlaubt!") - else: - ergebnis = op1 / op2 - else: - ergebnisOk = False - print("Keine gültige Eingabe!") - if ergebnisOk: - print(f"Das Ergebnis ist: {ergebnis}") - \end{codeBlock} - \end{solution} - \end{subtask*} -\end{task} -\begin{task}[points=auto]{Zum Weiterdenken \stage3} - \begin{subtask*}[points=0]{Entscheidungsbaum} - Wenn große Mengen von Daten verarbeitet werden müssen, geht es oft darum, diese in bestimmte Gruppen bzw. Klassen einzuteilen, zum Beispiel sollen häufig fehlerhafte Daten von korrekten getrennt werden. Eine mögliche Klassifikationsmethode, die für Tabellendaten genutzt werden kann, ist ein Entscheidungsbaum.\\ - \\ - Entscheidungsbäume funktionieren so, dass man für einen Datenpunkt (also eine Tabellenzeile) nach und nach die Spalteneinträge überprüft, bis man an einem Punkt ankommt, wo man sicher die Klasse festlegen kann. Das kann je nach dem, in welcher Reihenfolge man die Spalten betrachtet, unterschiedlich kompliziert sein (manchmal reicht sogar eine einzelne Spalte, um sicher zu wissen, welche Klasse es ist).\\ - \\ - Deine Aufgabe ist es, mit den Daten in der folgenden Tabelle einen Entscheidungsbaum zu konstruieren, der euch ausgibt, wann es sich lohnt, ins Freibad zu gehen (so, wie es in der Tabellenspalte ganz rechts festgelegt ist). Lege dazu am Besten pro Spalte eine Variable an, wo du dann Zeile für Zeile die Werte nacheinander durchprobieren kannst, um deine Implementierung zu testen. - \begin{table}[ht] - \centering - \begin{tabular}{|c|c|c|c|c|} - \hline - Wettervorhersage & Temperatur & Luftfeuchtigkeit & Wind & Freibad \\\hline - sonnig & 29 & hoch & false & Ja \\\hline - sonnig & 29 & mittel & true & Ja \\\hline - regen & 13 & mittel & true & Nein \\\hline - bewölkt & 22 & mittel & false & Ja \\\hline - regen & 13 & hoch & false & Nein \\\hline - bewölkt & 29 & mittel & false & Ja \\\hline - sonnig & 14 & mittel & true & Nein \\\hline - bewölkt & 27 & hoch & true & Ja \\\hline - bewölkt & 14 & hoch & true & Nein \\\hline - sonnig & 20 & mittel & false & Ja \\\hline - regen & 27 & mittel & false & Nein \\\hline - bewölkt & 14 & mittel & false & Nein \\\hline - regen & 20 & mittel & true & Nein \\\hline - sonnig & 22 & hoch & true & Ja \\\hline - sonnig & 14 & hoch & false & Ja \\\hline - bewölkt & 22 & mittel & true & Nein \\\hline - regen & 29 & mittel & true & Nein \\\hline - regen & 22 & hoch & false & Nein \\\hline - \end{tabular} - \end{table} - \newpage - Wenn du überprüfen möchtest, ob dein Entscheidungsbaum gut funktioniert, kannst du auch noch diese Datenpunkte ausprobieren: - \begin{table}[ht] - \centering - \begin{tabular}{|c|c|c|c|c|} - \hline - Wettervorhersage & Temperatur & Luftfeuchtigkeit & Wind & Freibad \\\hline - bewölkt & 15 & hoch & false & Nein \\\hline - sonnig & 28 & mittel & false & Ja \\\hline - sonnig & 21 & hoch & false & Ja \\\hline - regen & 27 & hoch & false & Nein \\\hline - regen & 20 & mittel & false & Nein \\\hline - bewölkt & 28 & hoch & false & Ja \\\hline - sonnig & 13 & hoch & true & Nein \\\hline - bewölkt & 21 & hoch & false & Ja \\\hline - regen & 27 & hoch & true & Nein \\\hline - \end{tabular} - \end{table} - - \textit{Hinweis: Euer Programm soll am Ende so funktionieren, dass ihr die Eckdaten (also Wettervorhersage, Temperatur, Luftfeuchtigkeit und Wind) eingebt, und das Programm dann Antwortet, ob ihr ins Freibad gehen solltet oder nicht.} - - \begin{solution} - \begin{codeBlock}[]{minted language=python} - // hier die Werte eintragen - wettervorhersage : string = "regen" - temperatur : int = 27 - luftfeuchtigkeit : string = "hoch" - windig : bool = True - - // Die Zahlenwerte, gegen die verglichen wird, - // können von den hier eingetragenen abweichen. - // Eure Lösung kann auch anders vorgehen, wenn die Testdaten - // korrekt erkannt werden, stimmt sie wahrscheinlich trotzdem. - - freibad : bool = False - - if wettervorhersage == "regen": - freibad = False - elif temperatur > 24: - freibad = True - elif wettervorhersage == "sonnig": - freibad = !(temperatur < 18 && windig) - else: - freibad = temperatur >= 18 && !windig - - if freibad: - print("Geh ins Freibad") - else: - print("Bleib zu Hause") - \end{codeBlock} - \end{solution} - \end{subtask*} - \begin{subtask*}[points=0]{Ein einfacher Prozessor} - Prozessoren bestehen im allgemeinen aus einer kleinen Anzahl von Registern, mit denen die eigentlichen Berechnungen durchgeführt werden. Im Folgenden sollt ihr das Verhalten eines kleinen Prozessors in Python simulieren. \\ - Der Prozessor soll aus 4 Registern bestehen, die beliebige Werte speichern können (Diese könnt ihr als Variablen modellieren). Außerdem kann der Prozessor grundlegende Berechnungen ({\ttfamily +, -, *, /, \%}) auf seinen Registern durchführen und Werte in Registern vergleichen (\textbf{Achtung:} Ihr müsst also nach jeder einzelnen Rechung oder einem Vergleich das Ergebnis in eines der Register speichern, und dürft nicht mehrere Rechnungen nacheinander ausführen (Also statt \pythoninline{a = 2 + 3 * 4} müsstet ihr \pythoninline{b = 3 * 4} gefolgt von \pythoninline{a = 2 + b} schreiben. If-Abfragen sind auf diese Art möglich: \pythoninline{if (a)}, also kein \pythoninline{else} und ihr müsst den Wahrheitswert, den ihr mit if überpfürt, zuerst in ein Register schreiben.)) \\ - In den Berechnungen dürft ihr außer den Registern auch Zahlenwerte verwenden, jedoch nicht das Register in das das Ergebnis geschrieben wird.\\ - Erstellt nun mit diesen Randbedinungen ein Programm, dass das folgende tut: \\ - \begin{codeBlock}[]{minted language=python} - lese eine Ganzzahl a ein - lese eine Ganzzahl b ein - lese eine Ganzzahl c ein - verdoppele a und addiere 3 hinzu - lese eine Ganzzahl d ein - gib b und c aus - wenn a > d gilt, setze d = a - wenn a < d gilt, speichere Wert c = d - a, sonst speichere Wert c = 0 - setze a = c * d + a * a - setze Wert b = a + d - setze c = b + d - gib a,b,c und d aus - \end{codeBlock} - - \begin{solution} - \begin{codeBlock}[]{minted language=python} - a : int = int(input("Ganzzahl a: ")) - b : int = int(input("Ganzzahl b: ")) - c : int = int(input("Ganzzahl c: ")) - a *= 2 - a += 3 - d : int = int(input("Ganzzahl d: ")) - print(b) - print(c) - b = a > d - if b: - d = a - b = a < d - if b: - c = d - a - b = !(b) - if b: - c = 0 - b = a * a - a = int(b) - - b = c * d - c = a + int(b) - a = c - b = a + d - c = int(b) + d - - print(a) - print(b) - print(c) - print(d) - \end{codeBlock} - \end{solution} - \end{subtask*} \end{task} \end{document} diff --git a/exercises/Aufgabe3.tex b/exercises/Aufgabe3.tex index 14d3a9d..700cfd1 100644 --- a/exercises/Aufgabe3.tex +++ b/exercises/Aufgabe3.tex @@ -11,15 +11,24 @@ $$1+2+3+\ldots+n = \sum_{k=1}^nk=\frac{n\cdot(n+1)}{2}$$ (i) Berechne die Summe der Zahlen von \pythoninline{1} bis \pythoninline{100} mit Hilfe der Gaußschen Summenformel. - (ii) Nun soll die Summe nicht mit Hilfe der geschlossenen Darstellung der Reihe berechnet werden, sondern unter Verwendung einer \textbf{for-Schleife}. + (ii) Nun soll die Summe nicht mit Hilfe der geschlossenen Darstellung der Reihe berechnet werden, sondern unter Verwendung einer \textbf{While-Schleife}. \begin{solution} (i) Nach der Summenformel gilt: $\frac{100\cdot(100+1)}{2} = \underline{\underline{5050}}$ (ii) \begin{codeBlock}[]{minted language=python} summe : int = 0 + k: int = 1 + while k < 101: + summe = summe + k + k = k + 1 - for k in range(1, 101): + print(f"Die Summe von 1 bis 100 ist {summe}.") + \end{codeBlock} + + (ii alternativ) \begin{codeBlock}[]{minted language=python} + summe : int = 0 + for k in range(1,101): summe = summe + k print(f"Die Summe von 1 bis 100 ist {summe}.") @@ -54,15 +63,15 @@ \begin{solution} \begin{codeBlock}[]{minted language=python} - for zahl in range(1, 100): - istDurch3Teilbar : int = zahl % 3 == 0 - istDurch5Teilbar : int = zahl % 5 == 0 + for zahl in range(1, 101): + ist_durch_3_teilbar: int = zahl % 3 == 0 + ist_durch_5_teilbar: int = zahl % 5 == 0 - if istDurch3Teilbar and istDurch5Teilbar: + if ist_durch_3_teilbar and ist_durch_5_teilbar: print("FizzBuzz") - elif istDurch3Teilbar: + elif ist_durch_3_teilbar: print("Fizz") - elif istDurch5Teilbar: + elif ist_durch_5_teilbar: print("Buzz") else: print(zahl) @@ -72,15 +81,15 @@ \begin{subtask*}[points=0]{Primzahl \stage3} Gegeben ist folgendes Listing: \begin{codeBlock}[]{minted language=python} - prime : int = 7 // Hier die Zahl + prime : int = 7 # Hier die Zahl - isPrime : bool = True - // Hier den Code einfügen + is_prime : bool = True + # Hier den Code einfügen - if isPrime: - // Hier den Code einfügen + if is_prime + # Hier den Code einfügen else: - // Hier den Code einfügen + # Hier den Code einfügen \end{codeBlock} \begin{enumerate} \item Ergänzt das Programm. Es soll erkennen, ob es sich bei der Variable \textbf{prime} um eine Primzahl\footnote{\href{https://de.wikipedia.org/wiki/Primzahl}{Jede natürliche Zahl, die nur durch sich selbst und 1 teilbar ist.}} handelt. Testet euer Programm mit verschiedenen Werten. @@ -118,9 +127,9 @@ \begin{solution} \begin{codeBlock}[]{minted language=python} - // Hier die Liste einsetzen + # Hier die Liste einsetzen liste = [1,1,2,3,5,8,13,21] - // liste = [-1,1,-1,1,-1,1,-1,1] + # liste = [-1,1,-1,1,-1,1,-1,1] val summe = liste[1] + liste[2] + liste[7] print(f"1. Die Summe der Zahlen an Index 1, 2 und 7 ist {summe}") @@ -134,75 +143,27 @@ \end{solution} \end{subtask*} \begin{subtask*}[points=0]{Listenlänge \stage1} - In der Vorlesung wurde \pythoninline{liste.size} eingeführt um die Länge einer - Liste zu bestimmen. Überlegt euch warum der Ausdruck \pythoninline{liste[liste.size]} + In der Vorlesung wurde \pythoninline{len(liste)} eingeführt um die Länge einer + Liste zu bestimmen. Überlegt euch warum der Ausdruck \pythoninline{liste[len(liste)]} immer zu einem Fehler führt. Schreibt nun ein Programm, dass für beliebige Listen alle Elemente der Reihe nach ausgibt. Ihr könnt dafür eine \pythoninline{while}-Schleife verwenden. \begin{anmerkung} - \pythoninline{liste.toString()} ist natürlich nicht erlaubt ;) + \pythoninline{print(liste)} und \pythoninline{str(liste)} ist natürlich nicht erlaubt ;) \end{anmerkung} \begin{solution} Da die Indices bei 0 anfangen ist \pythoninline{len(liste) - 1} der letzte gültige Index. \begin{codeBlock}[]{minted language=python} - list = [1, 2, 3, 4, 5] // Beispiel-Liste + list = [1, 2, 3, 4, 5] # Beispiel-Liste - index : int = 0 + index: int = 0 while index < len(list): element = list[index] print(f"Element {index}: {element}") - index += 1 - \end{codeBlock} - \end{solution} - \end{subtask*} -\end{task} -\begin{task}[points=auto]{Fortgeschrittenes Lesen} - \begin{subtask*}[points=0]{Einer für alle und alle für einen! \stage2} - Slicing ermöglicht es, nur einen Teil einer Liste zu verwenden. - So gilt etwa \\\pythoninline{[1, 2, 3, 4][1:3] == [2, 3]}. - Ein Slicing bekommt, wie bei Schleifen, eine Range \pythoninline{a..b step c}. - Was kann weggelassen werden. Welchen Wert wird verwendet, - wenn dieser leer gelassen werden? - - Was ist der Unterschied zwischen \pythoninline{a .. b} - und \pythoninline{a until b}? - - Wie geht man von großen zu kleinen Zahlen? - - \begin{solution} - Man kann \pythoninline{step c} weglassen. - Dann wird \pythoninline{step 1} genutzt. - - Bei \pythoninline{until} wird schon vor \pythoninline{b} gestoppt. - - \pythoninline{10 downTo 0} ist eine Möglichkeit. - \end{solution} - \end{subtask*} - \begin{subtask*}[points=0]{Slicing-Beispiele \stage2} - Findet Slicing-Ausdrücke für die folgenden Fragen zur Liste \pythoninline{liste}: - - \begin{enumerate} - \item Die gesamte Liste - \item Die Liste rückwärts - \item Jedes zweite Element - \item Das erste Element und jedes dritte danach mit Indices kleiner $7$ - \item Elemente an Index $6$, $5$, $4$ und $3$ - \item Nur das erste Element - \end{enumerate} - - \begin{solution} - \begin{codeBlock}[]{minted language=python} - liste = [1, 2, 3, 4, 5, 6, 7, 8, 9] - - print(liste[0, len(liste)]) // [1, 2, 3, 4, 5, 6, 7, 8, 9] - print(liste.slice(liste.size - 1 downTo 0)) // [9, 8, 7, 6, 5, 4, 3, 2, 1] - print(liste.slice(1 until liste.size step 2)) // [2, 4, 6, 8] - print(liste.slice(0..6 step 3)) // [1, 4, 7] - print(liste.slice(6 downTo 2)) // [7, 6, 5, 4] - print(liste.slice(0 until 1)) // [1] + index = index + 1 \end{codeBlock} \end{solution} \end{subtask*} @@ -231,34 +192,6 @@ \end{codeBlock} \end{solution} \end{subtask*} - \begin{subtask*}[points=0]{Text-Slicing \stage3} - Slicing funktioniert auch mit Text. Dabei wird der Text wie eine Liste von - Buchstaben behandelt. \\ - \pythoninline{"Hallo Welt!"[0:5]} ergibt beispielsweise - den String \pythoninline{"Hallo"}. Schafft ihr es, mittels Slicing ein - Palindrom zu erkennen? \textit{Ein Palindrom ist ein Wort, das vorwärts und rückwärts - identisch ist}. - - \begin{solution} - \begin{codeBlock}[]{minted language=python} - test : str = input("Gib hier dein Wort ein: ") - - fullLength = len(test) - halfLength = fullLength / 2 - - if test[0:halfLength+1] == test[fullLength-1:fullLength-halfLength]): - print("Palindrom") - else: - print("Kein Palindrom") - - // Kurze Lösung - if test == test[::-1]: - print("Palindrom") - else: - print("Kein Palindrom") - \end{codeBlock} - \end{solution} - \end{subtask*} \begin{subtask*}[points=0]{Akkumulator \stage2} Häufig gibt es in Programmen eine Variable in der das Ergebnis langsam aufgebaut wird. Beispielsweise ist diese für eine Summe zu Anfang $0$. Danach wird diese @@ -290,8 +223,8 @@ quadrate = [] for zahl in liste: - summe += zahl - produkt *= zahl + summe = summe + zahl + produkt = produkt * zahl quadrate.append(zahl * zahl) print(summe)