====== Programmieren Teil 2 – Rechnen, Strings und While-Schleife ======
  * Dieses Seite ist die Fortsetzung von [[gf_informatik:programmieren_i_gra|]]. 
  * Weiter zu [[gf_informatik:programmieren_iii_gra|]].
++++Lernziele:|

   * Grundsätzlich: Ich schreibe meinen **Code clever und elegant**. Es geht nicht nur darum, ob der Code das macht, was er soll, sondern auch darum, *wie* der Code geschrieben wurde.
   * Ich kann die wichtigsten **Vergleichsoperatoren** (`<,>,<=,>=,!=,==`) verwenden, um Zahlen miteinande zu vergleichen
   * Ich kann mit den wichtigsten **mathematischen Operatoren** rechnen (`+,-,*,/,//,%,**`).
   * Ich kann den Zuweisungsoperataor `=` und den Vergleichsoperator `==` richtig verwenden.
   * Ich kann mit **f-Strings** arbeiten und Werte von Variablen am richtigen Ort im String einsetzen.
   * Ich kann **komplexere Grafiken** mit der Turtle elegant mit Schleifen programmieren, zum Beispiel:
     * spiralförmige Muster
     * sich wiederholende Muster (gleiches Symbol mehrfach nebeneinander)
   * Ich kann mit **while-Schleifen** einen Codeblock wiederholen lassen, z.B.:
     * Fix vorgegebene Anzahl Wiederholungen.
     * Zahlen herauf / herunter zählen.
   * Ich kann die Funktionen ''print()'' und ''input()'' korrekt und sinnvoll verwenden.
   * Ich kann **while-Schleifen** und **Verzweigungen** kombinieren, z. B. um in einer Zahlenreihe bestimmte Zahlen abzufragen.
   * Ich verwende **KEIN REPEAT** mehr. Nie mehr!
   * Ich kann mit **break** aus einer "Endlosschleife" ausbrechen.

++++
===== - Rechnen & Strings =====

==== Rechnen ====

Mit Python kann man besser rechnen als mit jedem Taschenrechner. Unter anderem gibt es alle gängigen Rechenoperationen wie $+,-,\cdot,/$ und viele weitere **mathematische Operatoren** in Python:

^ Funktion ^ Python-Code ^
| Addition | `7 + 3` |
| Subtraktion | `7 - 3` |
| Multiplikation | `7 * 3` |
| Division (mit Nachkommastellen) | `7 / 3` |
| Ganzzahldivision | `7 // 3` |
| Modulo (Rest der Ganzzahl-Division, Bsp. `17 % 5 = 2`) | `17 % 2`|
| Hoch (z.B. 2 hoch 5) | `2**5` |

Erinnerung: Wenn wir einer Variable einen Wert zuweisen, verwenden wir die ** Zuweisungsanweisung** `=`. Dieser weist der *Variablen auf der linken Seite* den *Wert auf der rechten Seite* zu, also z.B. `x = 42`. Damit kann man auch den Wert einer Variable erhöhen oder verringern:
<code python>
x = 42 # Variable x mit Wert 42
print(x) # Ausgabe: 42
x = x + 1 # Rechte Seite ergibt 43. Dieser Wert wird nun x zugewiesen
print(x) # Ausgabe: 43
</code>

==== Strings ====

Ein **String** ist nichts anderes als *Text*, der zum Beispiel in einer Variable gespeichert wird:

<code python>
name = "Hans Müller" # Variable name hat Wert "Hans Müller" und ist ein String
</code>

== f-Strings ==

Wir werden nun vermehrt Werte berechnen, die wir dann in einem schönen Format ausgeben wollen. Am einfachsten geht dies mit sogenannten f-Strings: Diese erlauben es einem, einen String mit dem Wert einer Variable zu kombinieren:

<code python>
age = input("Wie alt bist du?") # Benutzerin wird nach Alter gefragt, wird in Variable age gespeichert.
print(f"Du bist {age} Jahre alt") # Der Wert der Variable age (also das Alter) wird im String eingefügt.
</code>

Falls die Benutzerin $15$ eingibt, gibt der Code dann also "Du bist 15 Jahre alt" aus. Beachte:

   * Vor dem String muss zwingend `f` stehen, was für *formatiert* steht.
   * Die Variable, von der der Wert eingefügt werden soll, muss in geschwungenen Klammern `{...}` stehen.

==== Aufgaben G ====

=== Aufgabe G1 ===

Berechne mithilfe von Python. Verwende dazu die Rechenoperatoren in der Tabelle oben.

   1. $62342+43169 = $
   1. $287 \cdot 63 = $
   1. $7731 : 532 = $
   1. $\cfrac{(24\cdot 9)^3+10077697}{13} = $

Die Resultate kannst du mit ''print()'' ausgeben. Prüfe, ob sie stimmen:

++++ Resultate:|
  - 105511
  - 18081
  - 14.531954887218046
  - 1550414.8461538462
++++

=== Aufgabe G2 ===

Frage die Benutzer:in der Reihe nach ihrem Namen, Alter und Wohnort (separate input-Befehle). Gib dann eine schöne Zusammenfassung aller Eingaben mittels eines formatierten Strings (f-String) aus.

*Beispiel:*
   * Eingaben:
     * "Hans Müller"
     * 42
     * "Romanshorn"
   * Ausgabe: "Du heisst Hans Müller, bist 42 Jahre alt und wohnst in Romanshorn."

=== Aufgabe G3 ===

Frage die Benutzer:in nach ihrem Alter in Jahren. Berechne nun ihr Alter ...
   * in Jahren
   * in Monaten
   * in Tagen
   * in Sekunden

Gib die Resultate schönt formatiert aus. Keep it simple, ignoriere Schaltjahre.

*Beispiel:* Falls Eingabe $7$ ist, sollen Ausgaben sein:

<code>
Alter in Jahren:   7
Alter in Monaten:  84
Alter in Tagen:    2555
Alter in Sekunden: 220752000
</code>

=== Aufgabe G4 ===

Programmiere einen **Countdown**. In der Konsole soll also ausgegeben werden:

<code>
10
9
8
7
6
5
4
3
2
1
Los!
</code>

++++Tipps:|Verwende repeat-Schleife. Starte mit einer Variable, z.B. `number = 10`. Verringere nun `number` in jedem Durchgang der Schleife um 1.++++

*Optional:* Summiere alle Zahlen auf. Berechne also $10 + 9 + 8 + \ldots + 1$. Was erhält man, wenn man den Countdown bei $100$ startet?


=== Aufgabe G5 ===

**Gerade oder ungerade** – Die Benutzer:in gibt eine Zahl ein. Dein Programm überprüft, ob die Zahl gerade ist oder nicht und gibt entsprechend eine der folgenden Meldungen aus:
  * "Die Zahl ist gerade." oder
  * "Die Zahl ist ungerade."

++++Tipp:|Der `%`-Operator, auch Modulo-Operator genannt, gibt den Rest der Ganzzahldivision zurück. Beispiel: 5 `%` 2 ergibt 1.++++


=== Aufgabe G6 ===

**M&M's-Verteiler:** Zusammen mit ein paar Freunden kaufst du dir eine Tüte M&M's. Diese werden dann gleichmässig verteilt. Schreibe nun folgenden Code:

   * Frage die Benutzer:in nach der Anzahl M&M's in der Tüte.
   * Frage die Benutzer:in nach der Anzahl Freunde.
   * Der Code gibt dann schön formatiert aus, wie viele M&M's jede Person erhält ...
   * ... und wie viele übrig bleiben.

Beispiel: Für $39$ M&M und $4$ Freunde soll ausgegeben werden: "Es gibt 9 M&M pro Person und es bleiben 3 Stück übrig."

++++Tipps:|Verwende `//` und `%` Operatoren.++++

=== Aufgabe G7 ===

**Vielfaches von 3** – Die Benutzerin kann eine beliebige (ganze) Zahl eingeben. Dein Code gibt eine Meldung aus, die 
  * die eingegebene Zahl wiederholt und 
  * sagt, ob diese Zahl ein Vielfaches von 3 ist oder nicht.
Beispiel-Ausgabe: "Die Zahl 34 ist kein Vielfaches von 3."

=== Aufgabe G8 ===

Zeichne mit einer Turtle die folgende Figur:

{{:gf_informatik:circles.png?direct&400|}}

++++Tipps:|

   * Definiere eine Variable für die Startposition (genauer: dessen $x-$Koordinate).
   * Zeichne einen Kreis.
   * Addiere zur Startposition-Variable einen passenden Wert.
   * Wiederhole in einer Schleife.

++++

=== Aufgabe G9 ===

Zeichne mit einer Turtle die folgende Figur:

{{:gf_informatik:squares.png?direct&400|}}

++++Tipps:|

   * Ähnlich wie die letzte Aufgabe.
   * Nur muss im Gegensatz zu einem Kreis (ein einziger Befehl) ein Quadrat mit einer Schleife erzeugt werden.
   * Du brauchst also eine zweite Schleife //in// der ersten Schleife.

++++

===== - While-Schleife =====

Mit einer **Schleife** kann man einen **Codeblock wiederholt ausführen** lassen und zwar solange, wie eine vorgegebene *Bedingung erfüllt* ist.

<code python>
while <Bedingung>:
    # Hier Codeblock, der wiederholt werden soll,
    # solange die Bedingung erfüllt ist.
    # Allen Zeilen, die zum Codeblock gehören
    # müssen eingerückt sein.

# hier Code, der NACH der while-Schleife ausgeführt werden soll
</code>


Alle Zeilen Code, die zum Codeblock der Schleife gehören werden //eingerückt//. Verwende dazu die //Tab//-Taste oben links. Nachdem der ganze Codeblock ausgeführt wurde, wird die Bedingung erneut überprüft. Ist sie immer noch erfüllt, wird der gleiche Codeblock wieder ausgeführt usw.


== Beispiel: ==
Folgender Code zeichnet eine rechtwinklige Spirale wie im Bild unten. Am Ende der Spirale wird ein ruter Punkt gezeichnet.
<code python>
from gturtle import *
morla = Turtle()

seite = 10

while seite <= 100:
    morla.forward(seite)
    morla.right(90)
    seite = seite + 10

morla.setPenColor("red")
morla.dot(40)
</code>

{{:gf_informatik:programmieren_ii_gra:pasted:20241126-092700.png?200|}}

\\
<color red>Ab sofort gilt ein komplettes Verbot der **repeat-**Schleife. Verwende stattdessen die **while-Schleife**.</color>
==== Aufgaben H ====

=== Aufgabe H1 ===

**Zählen:** Gib alle Zahlen von $0$ bis und mit $42$ in der Konsole aus. Verwende eine while-Schleife.

Ausgabe:
<code>
0
1
2
...
41
42
</code>

=== Aufgabe H2 ===

**It's (not) the final countdown:** Programmiere wieder einen Countdown, diesmal aber natürlich mit einer while-Schleife.

Ausgabe:
<code>
10
9
8
...
2
1
Los!
</code>

++++Tipps:|

Anstelle aufwärts zu zählen, zählt man hier abwärts:

   * Lege Variable (z.B. `count` oder `countdown`) auf Startwert fest.
   * Verringere den Wert dieser Variable in jedem Durchlauf der Schleife.

++++

=== Aufgabe H3 ===

**Quadrat III:** Lasse wieder eine Turtle ein Quadrat zeichnen – mit einer while-Schleife!

=== Aufgabe H4 ===

**Summieren:** Berechne die Summe aller natürlicher Zahlen bis und mit $100$, also:
$$1 + 2 + 3 + \ldots + 98 + 99 + 100 = ???$$
Guess what? Genau, man soll wieder eine while-Schleife programmieren.

++++Tipps:|

   * Für die while-Schleife benötigt man natürlich wieder einen Counter, z.B. `count = 0` -> erhöhe in jedem Durchgang der Schleife um $1$.
   * Definiere eine zusätzliche Variable, z.B. `summe = 0`
   * Addiere in jedem Durchgang der Schleie den aktuellen Wert von `count` zu `summe`.

++++

=== Aufgabe H5 ===

Gib die ersten $100$ Zahlen der 7er-Reihe aus, also $7,14,21,\ldots$ $700$.

=== Aufgabe H6 ===
Zeichne eine Spirale aus Halbkreisen wie im Bild unten: 
  * Start mit Radius 10. Erhöhen in 10er-Schritten.
  * Bis zu einem Radius von 50 soll die Spirale blau sein.
  * Dann soll sie rot sein – bis zu einem Radius von 90.

{{:gf_informatik:programmieren_ii_gra:pasted:20241126-093909.png?200|}}

++++ Tipp:|
Verwende zwei while-Schleifen //nacheinander//.
++++

=== Aufgabe H7 ===
Zeichne ein Muster aus blauen Kreissegmenten und roten 20-px-Punkten wie im Bild unten. Benutze eine While-Schleife.

{{:gf_informatik:programmieren_ii_gra:pasted:20241126-114826.png?200|}}

=== Aufgabe H8 ===
Zeichne ein Muster aus Sechsecken wie im Bild unten. Die kleinen Sechsecke haben die Seitenlänge 30, das grosse Sechseck hat die Seitenlänge 100.

{{:gf_informatik:programmieren_ii_gra:pasted:20241126-141804.png?200|}}

++++ Tipp:|
Verwende zwei while-Schleifen //ineinander//.
++++

**Optional**: Verändere die Seitenlängen so, dass der Stern in der Mitte geschlossen ist.

=== Aufgabe H9 ===


{{:gf_informatik:programmieren_ii_gra:pasted:20241203-094600.png?200|}}

**Böse Sieben:** Schreibe eine Programm, das alle Zahlen von 1 bis 50 ausgibt, aber: Wenn es eine Zahl aus der Siebner-Reihe ist, soll statt der Zahl die Meldung "Bösi" ausgegeben werden.

=== Aufgabe H10 ===
**Ein mal eins gibt eins:** Schreibe ein Programm mit while-Schleife und aus ingesamt **vier Codezeilen**, das folgende Meldungen ausgibt:

"1 mal 1 gibt 1"

"2 mal 2 gibt 4"

...

"9 mal 9 gibt 81"

++++ Tipps:|
Benutze einen f-String.
++++

=== Aufgabe H11 ===
**Zahlen raten 1:** Schreibe ein Programm, bei dem die Benutzer:in eine geheime Zahl zwischen 1 und 12 erraten soll.
  * Solange die Benutzer:in die Zahl nicht errät, wird sie (erneut) aufgefordert, eine Zahl einzugeben.
  * Sobald die Benutzer:in die richtige Zahl errät, soll das Programm eine Meldung in folgendem Format ausgeben: "Die Zahl 7 ist richtig. Du hast 5 Versuche gebraucht."

=== Aufgabe H12 ===

== Reihen-Generator Version 1 ==
Schreibe ein Programm, bei dem die Benutzer:in die Reihe (Eine Zahl zwischen 1 und 9) eingeben kann. Dann werden die ersten zehn Zahlen dieser Reihe ausgegeben. Für die Eingabe $3$ würden also die Zahlen $3, 6, 9$ ... $30$ ausgegeben.

== Reihen-Generator Version 2 ==
Erweitere das Programm um folgende Funktionen:
  * Es wird gezählt, wieviele Vielfache von Vier in der Reihe vorkomen. Am Ende wird eine Meldung in folgendem Format ausgegeben: 
    * "In den ersten zehn Zahlen der $6$-Reihe hat es $5$ Vielfache von Vier."
  * Es wird die Summe aller Zahlen der Reihe berechnet. Am Ende wird eine Meldung in folgendem Format ausgegeben: 
    * "Die Summe der ersten zehn Zahlen der $6$-Reihe ist $330$."

== Reihen-Generator Version 3 – Optional ==
Erweitere das Programm um folgende Funktion:
  * Die Benutzer:in wird solange nach einer Reihe gefragt, bis sie eine Zahl zwischen 1 und 9 eingibt. Wenn sie also 0 (oder geringer) eingibt, wird sie erneut gefragt. Wenn sie 10 (oder höher) eingibt, wird sie erneut gefragt.

=== Aufgabe H13 ===
**Zimetschtern hani gern** – Schreibe ein Programm, bei dem die Benutzer:in eingeben kann, wie viele Zimtsterne sie essen möchte. Dann zeichnet dein Programm (mit einer Turtle, die versteckt ist) die entsprechende Menge Zimtserne in einer Reihe auf, siehe Bild. Hinweis: Der Winkel für einen fünfzackigen Stern beträgt 144 Grad.

{{:gf_informatik:programmieren_ii_gra:pasted:20250107-180027.png?300|}}

**Optional 1:** Die Zimtsterne werden in Reihen zu drei Sternen angeordnet, siehe Bild:

{{:gf_informatik:programmieren_ii_gra:pasted:20250107-181236.png?300|}}

**Optional 2:** Die Zimtsterne sollen so angeordnet werden, dass sie ein möglichst grosses Quadrat bilden. Wird eine Quadratzahl überschritten, so wird die Anzahl Spalten erhöht. Bei 9 Sternen sind es zum Beispiel 3 Spalten, ab 10 Sternen sind es 4 Spalten, ab 17 Sternen 5 Spalten etc.
===== - Endlosschleifen und Break =====

Eine While-Schleife wiederholt einen Codeblock solange, wie ihre Bedingung erfüllt ist. Wenn die Bedingung //immer// erfüllt ist, ist es eine **Endlosschleife**. Oft programmiert man aus Versehen eine Endlosschleife, es gibt aber auch viele Situationen, in denen dies erwünscht ist. Zum Beispiel will man typischerweise ein Game so lange spielen können, bis man keine Lust mehr hat (oder einem die Eltern zwingen, aufzuhören). Man verfolgt dann beim Programmieren den folgenden Ansatz:

1. Schreibe den Code in eine **Endlosschleife**:

<code python>
while True:
    # hier kommt der Codeblock,
    # der wiederholt werden soll
</code>

2. Sobald der Codeblock aber doch abgebrochen werden soll (z.B. wegen GameOver oder beim erfolgreichen Abschliessen des Spiels oder weil die Benutzerin keine Lust mehr hat), schreibt man das Keyword `break`. Dies **bricht die Schleife per sofort ab**.

== Beispiel: ==

Die Benutzer:in wird aufgefordert, die kleinste Pimzahl einzugeben. Sobald sie $2$ eingegeben hat, soll die Schleife abgebrochen und der Benutzer:in gratuliert werden:

<code python>
while True:
    number = input("Gib die kleinste Primzahl ein:")
    if number == 2:
        break
    else:
        print("Leider nicht, versuche es noch einmal")

print("Gratuliere, du hast die richtige Zahl, 2, eingegeben!")
</code>


==== Aufgaben I ====

Löse alle Aufgaben mit **while-Schleifen und break**.

=== Aufgabe I1 ===

**Negative Zahl:** Die Benutzerin soll solange aufgefordert, eine negative Zahl einzugeben, bis sie es geschafft hat. Gibt sie eine falsche Zahl ein, soll sie erneut aufgefordert werden.

=== Aufgabe I2 ===

**Code für Geheimtür:** Der Benutzer soll aufgefordert werden, das geheime Passwort ("spaghetti") einzugeben. Gibt er es falsch ein, wird "Zugang verweigert" ausgegeben. Macht er es richtig, wird "Zugang gewährt" ausgegeben und der Code abgebrochen.

=== Aufgabe I3 ===

**Unendliche Summe:** Die Benutzerin soll unendlich oft hintereinander aufgefordert werden, eine Zahl einzugeben. Die neu eingegebene Zahl wird zu den bisherigen hinzuaddiert und das aktuelle Resultat ausgegeben.

Um das Programm abzubrechen, kann die Benutzerin "q" (für Quit) eingeben.

=== Aufgaben I4 ===

**Zahlen raten 2:** Schreibe ein Programm, bei dem die Benutzer:in eine geheime Zahl zwischen 1 und 100 erraten soll.
  * Die Benutzer:in hat maximal 7 Versuche.
  * Wenn die eingegebene Zahl zu niedrig ist, erscheint eine passende Meldung. 
  * Ebenso, wenn die Eingabe zu hoch ist.
  * Die Input-Meldung zeigt jeweils an, welcher Versuch es ist (siehe Beispiel). 
  * Sobald die Benutzer:in die richtige Zahl errät, soll das Programm eine passende Meldung mit der Anzahl Versuche ausgeben (siehe Beispiel).

Beispiel für die Ein-und Ausgabe:
<code yaml>
Rate die geheime Zahl zwischen 1 und 100. Du hast maximal 7 Versuche.  
Versuch 1: 50  
Zu hoch!  
Versuch 2: 25  
Zu niedrig!  
Versuch 3: 37  
Richtig! Du hast die Zahl in 3 Versuchen erraten.
</code>

**Optional:** Gib eine Meldung "Game over." aus, wenn alle 7 Veruche falsch waren.
===== Zusatzaufgaben II =====
=== Random ===
Mit dem Modul random kannst du zufällige Zahlen erzeugen. Hier ein Beispiel:

<code python>
import random
zahl1 = random.randint(1, 9)
print(zahl1)
</code>
  - Die erste Zeile importiert das Modul random. 
  - In der zweiten Zeile wird zahl 1 auf eine zufällige Zahl zwischen 1 und 9 gesetzt. Bei der Funktion ''randint()'' gibst du in der Klammer den Bereich an, aus dem eine zufällige Zahl gewählt wird.
  - Die dritte Zeile gibt die Zahl aus.

[[https://webtigerpython.ethz.ch/?code=NobwRAdghgtgpmAXGGUCWEB0AHAnmAGjABMoAXKJMNGbAewCcyACBqCYumAHQgC8oACwA2ARmYBeVu04xMbDhjIAKUQWYBOAJS9sDJcoEjROiM3PNeViGAC-AXSA|Probiere es aus – führe den Code mehrmals aus!]]


=== Aufgabe Z1 – Additions-Quiz 1 ===

Schreibe ein Programm, bei dem die Benutzer:in mehrere Fragen folgender Art beantworten muss:
"Was gibt 3 plus 4?"

  * Die beiden Summanden werden jeweils zufällig besimmt und befinden sich im Bereich zwischen 1 und 12.
  * Das Programm prüft jeweils, ob die Eingabe korrekt war und gibt eine entsprechende Meldung aus ("richtig" oder "falsch").
  * Nach 5 Fragen wird die Meldung "Fertig" ausgegeben. Benutze eine While-Schleife.

=== Aufgabe Z2 – Additions-Quiz 2 ===

Erweitere das Additions-Quiz um folgende Funktionen:

  * Die Benutzer:in kann mit der Eingabe "q" das Quiz abbrechen.
  * Am Ende wird eine Meldung in folgendem Format ausgegeben: "Du hast 3 von 4 Aufgaben richtig gelöst." Bei dieser Meldung wurden also vier von fünf Aufgaben beantwortet und drei davon richtig. 

=== Aufgabe Z3 – Additions-Quiz 3 ===

Erweitere das Additions-Quiz um folgende Funktionen:

  * Die Anzahl Fragen ist unbegrenzt. Die Benutzer:in kann mit der Eingabe "q" das Quiz beenden.
  * Bei jeder richtigen Antwort erklingt ein 440-Hz-Ton, bei jeder falschen ein 262-Hz-Ton – jeweils für 250 Milisekunden. Benutze die Funktion ''playTone(frequency, duration)'' aus dem gturtle-Modul, siehe auch [[https://www.python-online.ch/index.php?inhalt_links=turtle/navigation.inc.php&inhalt_mitte=turtle/sound.inc.php|hier]].
  * Am Ende wird eine Meldung in folgendem Format ausgegeben: "Du hast 7 Aufgaben gelöst – davon 85.7 % richtig."

=== Aufgabe Z4 – Rechen-Quiz ===

Verändere das Additions-Quiz 3 wie folgt:
  * Die Tonfunktion kommt wieder raus (die Töne nerven mit der Zeit).
  * Neu werden nicht nur Additionsrechnungen, sondern auch Subtraktions-, Multiplikations- und Modulorechnungen gestellt. Dabei wird der Operator (+, -, *, %) jeweils zufällig bestimmt.


===== Lösungen =====

**Achtung:** Meist gibt es mehrere Lösungen. Nur weil deine Lösung anders ist als diejenige in den Musterlösungen unten, bedeutet dies nicht, dass deine nicht richtig/gut ist. Sende oder zeige im Zweifelsfall deine Lösung der Lehrperson.

<nodisp 1>

++++Lösungen G|

=== Aufgabe G1 ===

<code python>
print(62342 + 43169)
print(287 * 63)
print(7731 / 532)
print(((24*9)**3+10077697)/13)
</code>

=== Aufgabe G2 ===

<code python>
name = input("Wie heisst du?")
age = input("Wie alt bist du?")
residence = input("Wo wohnst du?")
print(f"Du heisst {name}, bist {age} Jahre alt und wohnst in {residence}.")
</code>

=== Aufgabe G3 ===

<code python>
age = input("Gib dein Alter ein.")

print(f"Alter in Jahren:     {age}")
print(f"Alter in Monaten:    {age * 12}")
print(f"Alter in Tagen:      {age * 365}")
print(f"Alter in Sekunden:   {age * 365 * 24 * 3600}")
</code>

=== Aufgabe G4 ===

<code python>
number = 10

repeat 10:
    print(number)
    number = number - 1

print("Los!")
</code>
oder
<code python>
number = 10

repeat number:
    print(number)
    number = number - 1

print("Los!")
</code>

=== Aufgabe G5 ===

<code python>
zahl = input("Bitte eine ganze Zahl eingeben:")

if zahl % 2 == 0:
    print("Die Zahl ist gerade")
else:
    print("Die Zahl ist ungerade")
</code>

=== Aufgabe G6 ===

<code python>
nr_mm_total = input("Wie viele M&M sind in der Packung?")
friends = input("Wie viele Freunde seid ihr?")
 
nr_mm_per_person = nr_mm_total // friends
mm_remaining = nr_mm_total % friends
 
print(f"Es gibt {nr_mm_per_person} M&M pro Person und es bleiben {mm_remaining} Stück übrig.")
</code>

=== Aufgabe G7 ===

<code python>
zahl = input("Bitte eine ganze Zahl eingeben:")

if zahl % 3 == 0:
    print(f"Die Zahl {zahl} ist ein Vielfaches von 3!")
else:
    print(f"Die Zahl {zahl} ist kein Vielfaches von 3.")
</code>

=== Aufgabe G8 ===

<code python>
from gturtle import *

morla = Turtle()

xpos = -200
radius = 20

repeat 10:
    morla.setPos(xpos,0)
    morla.rightArc(radius, 360)
    xpos = xpos + 2*radius
</code>

=== Aufgabe G9 ===

<code python>
from gturtle import *

morla = Turtle()
morla.hideTurtle()

xpos = -200
seite = 40

repeat 10:
    morla.setPos(xpos,0)
    repeat 4:
        morla.forward(seite)
        morla.left(90)
    xpos = xpos + seite * 1.2
</code>
++++

++++Lösungen H|

=== Aufgabe H1 ===
<code python>
count = 0

while count <= 42:
    print(count)
    count = count + 1  
</code>

=== Aufgabe H2 ===

<code python>
count = 10

while count > 0:
    print(count)
    count = count - 1 

print("Los!")
</code>

=== Aufgabe H3 ===
<code python>
from gturtle import *
morla = Turtle()

count = 0

while count < 4:
    morla.forward(50)
    morla.right(90)
    count = count + 1
</code>

=== Aufgabe H4 ===
<code python>
count = 1
summe = 0

while count <= 100:
    summe = summe + count
    count = count + 1

print(summe)
</code>

=== Aufgabe H5 ===
<code python>
count = 1

while count <= 100:
    print(count * 7)
    count = count + 1
</code>

=== Aufgabe H6 ===

<code python>
from gturtle import *
morla = Turtle()

radius = 10
winkel = 180

morla.setPenColor("blue")

while radius <= 50:
    morla.rightArc(radius, winkel)
    radius = radius + 10

morla.setPenColor("red")

while radius < 100:
    morla.rightArc(radius, winkel)
    radius = radius + 10
</code>

=== Aufgabe H7 ===

<code python>
from gturtle import *
morla = Turtle()

radius = 100
winkel = 60
count = 0

while count < 6:
    morla.setPenColor("blue")
    morla.rightArc(radius, winkel)
    morla.setPenColor("red")
    morla.dot(20)
    count = count + 1
</code>

=== Aufgabe H8 ===

<code python>
from gturtle import *
morla = Turtle()

count1 = 0

while count1 < 6:
    morla.forward(100)
    morla.right(60)
    
    count2 = 0
    while count2 < 6:
        morla.forward(30)
        morla.right(60)
        count2 = count2 + 1
        
    count1 = count1 + 1
</code>

=== Aufgabe H9 ===

<code python>
count = 1

while count < 50:
    if count % 7 == 0:
        print("Bösi")
    else:
        print(count)
    count = count + 1
</code>


=== Aufgabe H10 ===

<code python>
count = 1

while count < 10:
    print(f"{count} mal {count} gibt {count*count}")
    count = count + 1
</code>


=== Aufgabe H11 ===

<code python>
geheimzahl = 2
count = 1

vermutung = input("Errate die Geheimzahl zwischen 1 und 12:")

while vermutung != geheimzahl:
    count = count + 1
    vermutung = input("Errate die Geheimzahl zwischen 1 und 12:")

print(f"Die Zahl {geheimzahl} ist richtig. Du hast {count} Versuche gebraucht.")
</code>

=== Aufgabe H12 Version 1===

<code python>
faktor = 1
produkt = 0

reihe = input("Welche Reihe (1-9)?")

while faktor <= 10:
    produkt = reihe * faktor
    print(produkt)
    faktor = faktor + 1
</code>

=== Aufgabe H12 Version 2===

<code python>
faktor = 1
produkt = 0
anz_vierx = 0
summe = 0

reihe = input("Welche Reihe (1-9)?")

while faktor <= 10:
    produkt = reihe * faktor
    print(produkt)
    faktor = faktor + 1
    
    if produkt % 4 == 0:
        anz_vierx = anz_vierx + 1
        
    summe = summe + produkt
    
print(f"In den ersten zehn Zahlen der {reihe}-Reihe hat es {anz_vierx} Vielfache von 4.")
print(f"Die Summe der ersten zehn Zahlen der {reihe}-Reihe ist {summe}")
</code>

=== Aufgabe H12 Version 3===

<code python>
faktor = 1
produkt = 0
anz_vierx = 0
summe = 0

reihe = 0
while not 0 < reihe < 10:
    reihe = input("Welche Reihe (1-9)?")

while faktor <= 10:
    produkt = reihe * faktor
    print(produkt)
    faktor = faktor + 1
    
    if produkt % 4 == 0:
        anz_vierx = anz_vierx + 1
        
    summe = summe + produkt
    
print(f"In den ersten zehn Zahlen der {reihe}-Reihe hat es {anz_vierx} Vielfache von 4.")
print(f"Die Summe der ersten zehn Zahlen der {reihe}-Reihe ist {summe}")
</code>

=== Aufgabe H13 ===
<code python>
from gturtle import *
morla = Turtle()
morla.hideTurtle()

n_stars = input("Wie viele Sterne isst du?")

x_pos = 0

count_stars = 0
while count_stars < n_stars:
    
    # Position des Sterns setzen:
    morla.setPos(x_pos, 0)
    x_pos = x_pos + 150
    
    # Stern zeichnen:
    count_side = 0
    while count_side < 5:
        morla.forward(100)
        morla.left(144)
        count_side = count_side + 1

    count_stars = count_stars + 1
</code>

=== Aufgabe H13 – Optional 1 ===
<code python>
from gturtle import *
morla = Turtle()
morla.hideTurtle()
 
n_stars = input("Wie viele Sterne isst du?")
 
x_pos = 0
y_pos = 0
 
count_stars = 1
while count_stars <= n_stars:
 
    # Position des Sterns setzen:
    morla.setPos(x_pos, y_pos)
    
    # ...alle drei Sterne eine neue Reihe beginnen:
    if count_stars % 3 == 0:
        x_pos = 0
        y_pos = y_pos - 150
    else:
        x_pos = x_pos + 150
     
    # Stern zeichnen:
    count_side = 0
    while count_side < 5:
        morla.forward(100)
        morla.left(144)
        count_side = count_side + 1
 
    count_stars = count_stars + 1
</code>

=== Aufgabe H13 – Optional 2 ===
<code python>
from gturtle import *
morla = Turtle()
morla.hideTurtle()
 
n_stars = input("Wie viele Sterne isst du?")

# Anzahl Spalten für Quadrat ermitteln:
columns = 0
square_columns = 0
while square_columns < n_stars:
    columns = columns + 1
    square_columns = columns**2

x_pos = 0
y_pos = 0
 
count_stars = 1
while count_stars <= n_stars:
 
    # Position des Sterns setzen:
    morla.setPos(x_pos, y_pos)
    
    # ...alle [columns] Sterne eine neue Reihe beginnen:
    if count_stars % columns == 0:
        x_pos = 0
        y_pos = y_pos - 150
    else:
        x_pos = x_pos + 150
     
    # Stern zeichnen:
    count_side = 0
    while count_side < 5:
        morla.forward(100)
        morla.left(144)
        count_side = count_side + 1
 
    count_stars = count_stars + 1
</code>

++++

++++Aufgaben I|

=== Aufgabe I1 ===

<code python>
while True:
    number = input("Gib eine negative Zahl ein.")
    if number < 0:
        break
    else:
        print("Falsch. Try again!")

print("Korrekt!")
</code>

=== Aufgabe I2 ===

<code python>
while True:
    eingabe = input("Gib das geheime Passwort ein")
    if eingabe == "Spaghetti":
        print("Korrekt. Zutritt gewährt")
        break
    else:
        print("Falsch. Zugang verweigert. Try again!")
</code>

=== Aufgabe I3 ===

<code python>
summe = 0

while True:
    eingabe = input("Gib Zahl ein, die dazu addiert werden soll. Abbrechen mit 'q'.")
    if eingabe == 'q':
        break
    summe = summe + eingabe
    print(f"Die Summe bisher ist: {summe}")
    
print(f"Die finale Summe ist: {summe}")
</code>

=== Aufgabe I4 ===

<code python>
geheimzahl = 37
versuche = 0
max_versuche = 7

while versuche < max_versuche:
    tipp = input(f"Versuch {versuche + 1}: ")
    versuche = versuche + 1
    if tipp > geheimzahl:
        print("Zu hoch!")
    elif tipp < geheimzahl:
        print("Zu tief!")
    else:
        print(f"Richtig! Du hast die Zahl in {versuche} Versuchen erraten.")
        break

# Option Game over
if versuche == max_versuche and tipp != geheimzahl:
    print("Game over.")
</code>
++++

++++Aufgaben Z|

=== Aufgabe Z1 ===

<code python>
import random

min = 1
max = 12
count = 0

while count < 5:
    zahl1 = random.randint(min, max)
    zahl2 = random.randint(min, max)
    resultat = input(f"Was gibt {zahl1} plus {zahl2}?")
    if resultat == zahl1 + zahl2:
        print("richtig")
    else:
        print("falsch")
    count = count + 1
    
print("Fertig")
</code>

=== Aufgabe Z2 ===
<code python>
import random

min = 1
max = 12
count = 0
count_correct = 0

while count < 5:
    zahl1 = random.randint(min, max)
    zahl2 = random.randint(min, max)
    resultat = input(f"Was gibt {zahl1} plus {zahl2}?")
    if resultat == zahl1 + zahl2:
        print("richtig")
        count_correct = count_correct + 1
    elif resultat == "q":
        break
    else:
        print("falsch")
    count = count + 1
    
print(f"Fertig. Du hast {count_correct} von {count} Aufgaben richtig gelöst.")
</code>

=== Aufgabe Z3 ===
<code python>
import random
 
min = 1
max = 12
count = 0
count_correct = 0
 
while True:
    zahl1 = random.randint(min, max)
    zahl2 = random.randint(min, max)
    resultat = input(f"Was gibt {zahl1} plus {zahl2}?")
    if resultat == zahl1 + zahl2:
        playTone(440, 250)
        print("richtig")
        count_correct = count_correct + 1
    elif resultat == "q":
        break
    else:
        playTone(262, 250)
        print("falsch")
    count = count + 1

ratio = count_correct / count * 100
print(f"Fertig. Du hast {count} Aufgaben gelöst – davon {ratio:.1f} % richtig.")

</code>

=== Aufgabe Z4 ===
<code python>
import random

min = 1
max = 12
count = 0
count_correct = 0

while True:
    zahl1 = random.randint(min, max)
    zahl2 = random.randint(min, max)
    operator = random.randint(1, 4)
    
    if operator == 1:
        resultat = zahl1 + zahl2
        text = f"Was gibt {zahl1} plus {zahl2}?"
    elif operator == 2:
        resultat = zahl1 - zahl2
        text = f"Was gibt {zahl1} minus {zahl2}?"
    elif operator == 3:
        resultat = zahl1 * zahl2
        text = f"Was gibt {zahl1} mal {zahl2}?"
    else:
        resultat = zahl1 % zahl2
        text = f"Was gibt {zahl1} modulo {zahl2}?"

    eingabe = input(text)
    if eingabe == resultat:
        print("richtig")
        count_correct = count_correct + 1
    elif eingabe == "q":
        break
    else:
        print("falsch")
    count = count + 1
 
ratio = count_correct / count * 100
print(f"Fertig. Du hast {count} Aufgaben gelöst – davon {ratio:.1f} % richtig.")
</code>

++++
</nodisp>