====== Programmieren I: Grundlagen der Programmierung ======

++++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 erklären, was eine **Variable** ist und passende Analogien machen.
   * Ich kann erklären, wann und warum man Variablen verwenden sollte.
   * Ich kann eine Turtle erzeugen ...
   * ... und mit ihr **Figuren** mit geraden und gebogenen Linien zeichnen.
   * Ich kann die Turtle an eine beliebige Position **beamen**.
   * Ich kann erklären, was eine **Schleife** ist und warum diese praktisch sind.
   * Ich schreibe meinen Code so **elegant und kompakt** wie möglich. Dazu verwende ich:
     * Schleifen anstelle von Copy-Paste.
     * Variablen für Werte, die mehr als 1x benötigt werden im Code.
     * (Beachte: Bei Prüfungen wird nicht nur bewertet *ob* der Code korrekt funktioniert, sondern auch, wie elegant er programmiert wurde.)
   * Ich kann von der Benutzerin eine **Eingabe** verlangen und diese in einer Variable speichern.
   * Ich kann die wichtigsten **Vergleichsoperatoren** verwenden, um Zahlen miteinande zu vergleichen
   * Ich kann **Verzweigungen** (if,if-else,if-elif-else) programmieren.
   * Ich kann einfache **Konsolenprogramme** (Programme mit Eingabe und/oder Ausgabe aber *ohne Turtle*).
   * (Optional): Ich kann in **farbige Bilder** erstellen mit TurtleGraphics.

   * Ich kann mit den wichtigsten **mathematischen Operatoren** rechnen (`+,-,*,/,//,%,**`).
   * Ich kann den Zuweisungsoperataor `=` mit dem Vergleichsoperator `==` vergleichen.
   * Ich kann mit **f-Strings** arbeiten, zum Beispiel:
     * Mehrere Strings zusammenhängen
     * 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 verwende **KEIN REPEAT** mehr. Nie mehr!
   * Ich kann mit **break** aus einer "Endlosschleife" ausbrechen.


++++

===== - Einführung =====

Ein Computer ist zunächst einfach mal eine Maschine, die wahnsinnig schnell arbeiten (rechnen) kann. Damit man zum Beispiel ein Spiel spielen können, muss irgend jemand dem Computer also sagen, was er denn genau zu tun hat. Jemand muss also ein **Computerprogramm**, oder **Code**, schreiben. Dieses besteht aus //Befehlen, die der Computer auszuführen// hat. Damit der Computer auch versteht, was er machen soll, müssen Programmierer und Computer 'die gleiche Sprache' sprechen. Es gibt sehr viele unterschiedliche solche Programmiersprachen mit unterschiedlichen Anwendungsbereiechen und Vor- und Nachteilen.

Wir wählen hier die Programmiersprache **Python**. Im Jahre 2020 ist diese Sprache sicher in der Top 3 der wichtigsten Programmiersprachen - wenn nicht sogar auf dem ersten Platz. Dazu kommt, dass Python im Vergleich zu anderen Sprachen, z.B. C\+\+ (C Plus Plus), Java oder C# (C Sharp) relativ einfach zu erlernen ist. 

Wenn wir einen Satz mit vielen Schreibfelern und Grammatikfehler lesen, so sind wir meist trotzdem in der Lage, den Satz zu verstehen. Im Gegensatz zu uns hat ein Computer aber keine Intelligenz und ist deshalb nicht in der Lage, einen Text selbst zu interpretieren. Ein Computer kann ein Programm nur ausführen, wenn es gar keine Fehler, sogenannte **Bugs**, hat. Es ist deshalb ganz wichtig, dass man sich an die formalen Vorgaben der Programmiersprache hält.

Wie gesagt werden wir in der Programmiersprache Python programmieren. Wir brauchen aber noch ein Programm, um unseren Code zu schreiben und auszuführen, eine sogenannte **IDE (Integrated Development Environment, auf Deutsch Entwicklungsumgebung)**. Typischerweise sind Entwicklungsumgebungen Programme, die man auf seinem Computer installiert. Mittlerweile gibt es aber auch zahlreiche Online-Entwicklungsumgebungen, mit denen man arbeiten kann. Wir werden zuerst mit einer solchen arbeiten: [[https://webtigerpython.ethz.ch/]]

==== Arbeiten mit TigerPython ====

   1. Öffne die Web-IDE: https://webtigerpython.ethz.ch/
   1. Schreibe Code, führe aus (grüner Pfeil)
   1. **Speichere** regelmässig, in dem Code per Copy-Paste (CTRL C & V) in OneNote übertragen wird
   1. <color red>Alle Codes **müssen auf OneNote sauber geordnet abgelegt werden**. Vergisst man einen Code zu speichern, muss er **nochmals geschrieben** werden.</color>.

==== Tipps ====

   * Im Dossier gibt es viele kleine **Code-Beispiele**. Tippe diese jeweils //von Hand ab// und versuche, alles zu //verstehen//. Wenn du den Code per Copy-Paste kopierst, lernst du gar nichts!


===== - Einfache Bewegungen =====

Tippe folgenden Code in den Editor:

<code python>
from gturtle import *

fritz = Turtle()

fritz.forward(100)
</code>

Verwende anstelle von *fritz* deinen Namen (keine Bindestriche im Namen!)

Erklärung der Zeilen:
  - Zuerst musst du das *Modul gturtle importieren*, damit wir mit Turtlegrafik arbeiten können.
  - Erzeuge einen neuen Turtle mit einem Namen. Man nennt dieses auch ein *Turtle-Objekt*.
  - Gib deinem Turtle den Befehl, 100 Pixel vorwärts zu laufen.

Du kannst deinem Turtle nun auch sagen, er soll sich um einen gewissen Winkel drehen oder rückwärts laufen. Die wichtigsten Befehle sind:

^ Befehl ^ Beschreibung ^
| forward(s) | s Schritte (in Pixel) vorwärts bewegen         |
| back(s)    | s Schritte rückwärts bewegen                   |
| right(w)   | um den Winkel w (in Grad) nach rechts drehen   |
| left(w)    | um den Winkel w nach links drehen              |
| setPos(-100,50) | Setzt Turtle an Position (-100,50) |
| setX(30)     | setzt x-Koordinate des Turtles |
| setY(30)     | setzt y-Koordinate des Turtles |
| setHeading(w) | setzt die Richtung der Turtle (0 gegen oben, im Uhrzeigersinn) |
| hideTurtle()     | Turtle versteckt sich, darauf folgende Befehle werden instantan ausgeführt |

[[https://www.python-online.ch/index.php?inhalt_links=turtle/navigation.inc.php&inhalt_mitte=turtle/turtledoc.html|Link zur Dokumentation mit allen Befehlen]]

==== Aufgaben A ====

=== Aufgabe A1 ===

Programmiere deine Turtle so, dass es ein **Quadrat** abläuft. Die Position, in der sich die Turtle am Schluss befindet ist irrelevant. Auch ob die Figur etwas kleiner oder grösser gerät ist egal.

{{:gf_informatik:quadrat.png?direct&150|}}

++++Tipps:|forward und left / right++++

=== Aufgabe A2 ===

Programmiere nun ein **gleichseitiges Dreieck**.

{{:gf_informatik:dreieck.png?direct&150|}}

=== Aufgabe A3 ===

Und nun ein **regelmässiges Sechseck**.

{{:gf_informatik:sechseck_2.png?direct&150|}}

=== Aufgabe A4 ===

Zeichne nun zwei identische Quadrate nebeneinander:

{{:gf_informatik:zwei_quadrate.png?direct&350|}}

++++Tipps:|setPos++++

=== Aufgabe A5 ===

Programmiere deinen Turtle so, dass er **deinen Namen**, Spitznamen oder zumindest deine Initialen abläuft.

===== - Variablen und Schleifen =====

{{ :gf_informatik:programmieren_i_01_variablen_schleifen.pdf |Slides Variablen & Schleifen}}

<nodisp 2>

++++Code Warm-Up "KSR"|

<code python>
from gturtle import *
turi = Turtle()
turi.ht()
 
turi.forward(200)
turi.setPos(0,100)
turi.right(45)
turi.forward(141)
turi.setPos(0,100)
turi.right(90)
turi.forward(141)

turi.left(45)
turi.setPos(150,0)
turi.forward(100)
turi.left(90)
turi.forward(100)
turi.left(90)
turi.forward(100)
turi.right(90)
turi.forward(100)
turi.right(90)
turi.forward(100)

turi.right(90)
turi.setPos(300,200)
turi.forward(200)
turi.setPos(300,200)
turi.left(90)
turi.forward(100)
turi.right(90)
turi.forward(100)
turi.right(90)
turi.forward(100)
turi.left(135)
turi.forward(141)
</code>
++++

</nodisp>

Folgender Code erzeugt ein Quadrat mit Seitenlänge 120 Pixel:

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

fritz.forward(120)
fritz.left(90)
fritz.forward(120)
fritz.left(90)
fritz.forward(120)
fritz.left(90)
fritz.forward(120)
fritz.left(90)
</code>

Nun möchten wir das Quadrat aber grösser machen zu Seitenlänge $200$ Pixel. Dazu müssen wir jetzt die vier Werte mit $120$ zu $200$ ändern, was etwas *umständlich* ist. Es gibt einen einfacheren Weg: Wir **speichern** die gewünschte Seitenlänge in einer **Variable**, z.B. `l = 200`. Nun können wir einfach `fritz.forward(l)` schreiben und es wird für `l` der Wert $200$ eingefügt:


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

l = 200
fritz.forward(l)
fritz.left(90)
fritz.forward(l)
fritz.left(90)
fritz.forward(l)
fritz.left(90)
fritz.forward(l)
fritz.left(90)
</code>
Wenn wir die Seitenlänge nun wieder ändern wollen, so müssen wir nur den Wert der Variablen ändern, z.B. `l = 50`. Wichtig ist immer, dass man die Variable festlegt *bevor* man sie verwendet, also oberhalb im Code.

Weiter fällt auf, dass dieser Codeblock viel Copy-Paste beinhaltet: Der folgende Codeblock kommt 4x direkt hintereinander vor:
<code python>
fritz.forward(l)
fritz.left(90)
</code>

Deshalb können wir auch einfach sagen, dass dieser Codeblock 4x hintereinander wiederholt (-> repeated) werden soll:
<code python>
repeat 4:
    fritz.forward(l)
    fritz.left(90)
</code>
Da ein Codeblock mehrfach hintereinander ausgeführt wird, spricht man von einer **Schleife**.
Beachte, dass der Codeblock, der wiederholt werden soll, **eingerückt** sein muss. Verwende dazu die **Tabulatortaste**. Weiter ist es wichtig, den Doppelpunkt im repeat-Befehl nicht zu vergessen.

==== Aufgaben B ====


=== Aufgabe B1 ===

Nun wollen wir einige der Figuren aus A nochmals zeichnen, diesmal aber mithilfe von **Variablen** und **Schleifen**. Löse jede Aufgabe mit einem *eigenen Code* (also nicht alle Figuren zusammen):

   1. Quadrat
   1. Dreieck
   1. Sechseck

=== Aufgabe B2 ===

Zeichne eine Treppe mithilfe einer Variable und einer Schleife:

{{:gf_informatik:treppe.png?direct&200|}}

=== Aufgabe B3 ===

Zeichne folgende Figur (Variable optional):

{{:gf_informatik:stern.png?direct&150|}}

=== Aufgabe B4 ===

In einer A-Aufgabe hast du **zwei Quadrate** nebeneinander gezeichnet. Wahrscheinlich war dieser Code ziemlich lange. Schreibe jetzt einen Code, der das gleiche Bild erzeugt, der aber viel kürzer ist, indem du zwei Schleifen verwendest: Eine Schleife für jedes der Quadrate.

{{:gf_informatik:zwei_quadrate.png?direct&350|}}

=== Aufgabe B5 ===

Zeichne nun ein grosses und ein kleines Quadrat nebeneinander. Verwende wieder Variablen und Schleifen.

{{:gf_informatik:quadrate_gross_klein.png?direct&300|}}


===== - Kreisbogen =====

Um eine Turtle namens *fritz* einen **Punkt** mit Radius 20 Pixel zeichnen zu lassen, tippe einfach:

<code python>
fritz.dot(20)
</code>

Bisher haben wir unsere Turtles ausschliesslich gerade Linien laufen lassen. Um auf einem **Bogen** (engl. "arc") zu gehen, verwende die Befehle

<code python>
fritz.rightArc(r, w)
fritz.leftArc(r, w)
</code>

Diese beiden Funktionen zeichnen einen Bogen nach rechts (`rightArc`) und nach links (`leftArc`). Diesen Funktionen muss man zwei Zahlen als Argumente übergeben:

   * Zahl r: Radius des Kreises in Pixel
   * Zahl w: Winkel in Grad

Zum Beispiel zeichnet man mit dem Befehl `rightArc(100, 180)` einen Halbkreis (180 Grad Winkel) mit Radius 100 Pixel.



==== Aufgaben C ====

Freiwillig: Mit `setPenColor("red")` die Farbe ändern.
=== Aufgabe C1 ===

Verwende die Befehle `dot(), forward(), right(), left()`, um folgende Figur zu zeichnen:

{{:gf_informatik:turtle_zick_zack.png?direct&300|}}

Versuche nun deinen Code zu kurz wie möglich zu schreiben. Vermeide Code-Wiederholungen, in dem du eine **Schleife** programmierst. Definiere wo sinnvoll **Variablen**.

=== Aufgabe C2 ===

Zeichne nun folgende Figur, welche aus lauter Halbkreisen besteht:

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

Tipp: Verwende hier `leftArc(...)` und `rightArc()`.

=== Aufgabe C3 ===

Zeichne nun folgende Figur, welche aus drei Halbkreisen besteht:

{{:gf_informatik:halbkreise_2.png?direct&200|}}

Beachte, dass der grosse Halbkreis einen doppelt so grossen Radius hat wie die kleinen beiden Halbkreise. Man kann deshalb den grossen Radius über den kleinen Radius definieren:

<code python>
radius_1 = 70 # lege kleinen Radius fest
radius_2 = 2 * radius_1 # grosse Radius wird als 2x der kleine Radius definiert
</code>

===== - Farben (optional) =====

Wir können nun auch etwas Farbe ins Spiel bringen:

   * Mit `setPenColor("red")` kann man die Farbe des Stifts festlegen.
   * Mit `setPenWidth(10)` kann man die Dicke des Stifts festlegen.
   * Mit `clear("black")` ganz am Anfang des Codes (bevor man Turtle erzeugt) kann man die Hintergrundfarbe festlegen.
   * Mit `setFillColor("blue")`, `startPath()` und `fillPath()` kann man eine Fläche farbig ausfüllen.

[[https://www.python-online.ch/index.php?inhalt_links=turtle/navigation.inc.php&inhalt_mitte=turtle/turtledoc.html|In der Dokumentation findet man genauere Erklärungen zu diesen (und allen anderen) Turtle-Befehlen.]]

==== Aufgaben D ====

=== Aufgabe D1 ===

Zeichne ein farbiges Quadrat mit dicken Linien und einer Hintergrundfarbe:

{{:gf_informatik:quadrat_farbig.png?direct&150|}}

=== Aufgabe D2 ===

Zeichne einen Smiley:

{{:gf_informatik:smiley.png?direct&150|}}
=== Aufgabe D3 ===

Zeichne eine Ampel:

{{:gf_informatik:ampel.png?direct&100|}}

===== - Verzweigungen =====

**{{ :gf_informatik:programmieren_i_02_verzweigungen.pdf |Slides Verzweigungen}}**

In **Verzweigungen** werden Bedingungen überprüft. Je nachdem, wird *unterschiedlicher* Code ausgeführt.

**Beispiel 1:**

<code python>
answer = input("Was gibt 37 + 5?")

if answer == 42:
    print("Korrekt!")
else:
    print("Falsch!")

print("Auf Wiedersehen")
</code>

**Beispiel 2:**

<code python>
answer = input("Was gibt 37 + 5?")

if answer == 42:
    print("Korrekt!")
elif answer == 40:
    print("Fast, um 1 zu tief!")
elif answer == 41:
    print("Fast, um 1 zu hoch!")
else:
    print("Falsch!")

print("Auf Wiedersehen")
</code>

**Beispiel 3:**

<code python>
money = input("Wie viel Geld hast du?")

if money >= 1000000:
    print("Du bist Millionär!")
else:
    print("Du bist kein Millionär!")
</code>

**Vergleichsoperatoren:**

^ **Vergleichsoperator** ^ **Überprüft ob ...** ^
| `x == y` | x gleich y ist. |
| `x != y` | x *un*gleich y ist. |
| `x > y` | x grösser als y ist. |
| `x < y` | x kleiner als y ist. |
| `x >= y` | x grösser oder gleich y ist. |
| `x <= y` | x kleiner oder gleich y ist. |

==== Aufgaben E ====

Beachte: Einige Aufgaben sollen mit TurtleGraphics gelöst werden, andere ohne. Den TurtleCode `from gturtle import *` usw. soll nur dann geschrieben werden, wenn man auch eine Turtle hat.

=== Aufgabe E1 ===

Schreibe einen Code, in dem die Benutzerin dazu aufgefordert wird, deine Lieblingszahl zu erraten. Gelingt es ihr, so wird ihr gratuliert. Falls nicht, wird sie dafür kritisiert, dass sie dies nicht weiss.

=== Aufgabe E2 ===

   1. Die Benutzerin soll dazu aufgefordert werden, den Buchstaben "q" einzugeben. Fall sie dies macht, soll ein *Quadrat* gezeichnet werden. Falls irgendetwas anderes eingegeben wird, soll nichts gezeichnet werden. Stattdessen soll ausgegeben werden (mit `print("...")`), dass eine unzulässige Eingabe gemacht wurde.\\ \\
   1. Modifiziere nun den Code oben so, dass man (neben "q" für Quadrat) auch "d" eingeben kann, damit ein Dreieck gezeichnet wird.

=== Aufgabe E3 ===

**Witz-Sammlung:** Notiere 3 bis 5 (durchaus flache) Witze. Die Benutzerin soll aufgefordert werden, eine Zahl 1-... einzugeben. Gibt sie eine 1/2/3 ein, so soll der erste/zweite/dritte Witz angezeigt werden. Macht sie eine falsche Eingabe, so soll einfach *nicht* passieren.

=== Aufgabe E4 ===

**Volljährig Checker:** Die Benutzerin wird aufgefordert, ihr Alter einzugeben. Überprüfe ob sie volljährig ist oder nicht und gib entsprechend "volljährig" oder "minderjährig" aus. Beachte, dass es hier einen anderen Vergleichsoperator braucht als `==`: `< , > , <= , >=`.

=== Aufgabe E5 ===

**Positiv, Null oder negativ?** Die Benutzerin wird aufgefordert, eine Zahl einzugeben. Der Code gibt aus "positiv", "Null" oder "negativ".

=== Aufgabe E6 ===

**Grössere Zahl:** Die Benutzerin wird aufgefordert, *hintereinander* zwei Zahlen einzugeben. Speichere diese zwei Zahlen in unterschiedlichen Variablen. Die grössere der beiden Zahlen soll dann ausgegeben werden.

Beispiel: Falls zuerst $5$ und dann $7$ eingegeben wird, soll $7$ ausgegeben werden.
===== Zusatzaufgaben I =====

=== Race ===

   1. Zeichne mit Turtle eine eigene Map mit einer Rennbahn und weiteren Elementen (Gewässer, Bäume, Häuser, Menschen, ...). Verwende für diesen Teil den `.hideTurtle()` Befehl, damit die Map sofort gezeichnet ist.
   1. Zeige nachher die Turtle wieder an mit `.showTurtle()` und lasse die Turtle auf der Rennbahn Runden drehen. Mit `repeat:` kann ein Code unendlich oft wiederholt werden.

Beispiel:

{{:gf_informatik:rennbahn.png?direct&200|}}

<nodisp 2>

++++Code LP|

<code python>
from gturtle import *

length = 100
driver = Turtle()
driver.hideTurtle()
clear("green")

# Street
driver.setPenWidth(20)
driver.setPenColor("gray")

driver.setPos(0,0)
driver.right(90)

repeat 2:
    driver.forward(length)
    driver.leftArc(length,180)

# Finish Line
driver.setPenWidth(7)
driver.setHeading(0)
driver.setPos(length//2,-17)

repeat 4:
    driver.setPenColor("black")
    driver.forward(5)
    driver.setPenColor("white")
    driver.forward(5)

driver.setPos(length//2+5,-17)

repeat 4:
    driver.setPenColor("white")
    driver.forward(5)
    driver.setPenColor("black")
    driver.forward(5)

#River
driver.setHeading(0)
driver.setPos(0,-400)
driver.setPenWidth(50)
driver.setPenColor("blue")
driver.forward(200)
driver.rightArc(100,120)
driver.forward(100)
driver.leftArc(130,170)
driver.forward(40)
driver.rightArc(200,40)
driver.forward(300)

# Race
driver.penUp()
driver.setPos(0,0)
driver.setHeading(90)
driver.showTurtle()

repeat: # Endlosschleife
    driver.forward(length)
    driver.leftArc(length,180)
</code>

++++

</nodisp>

===== - 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>
(Überigens ist dieser Name laut ChatGPT der 'schweizeriste' Name).

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} = $

=== Aufgabe G2 ===

Frage die Benutzerin der Reihe (separate input-Befehle) nach ihrem Namen, Alter und Wohnort. Gib dann eine schöne Zusammenfassung aller Eingaben mittels eines schön 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 Benutzerin 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 ===

Zeichne mit einer Turtle die folgende eckige Spirale:

{{:gf_informatik:spirale_eckig.png?direct&200|}}

++++Tipp 1:|Jede Linie ist um 10 Pixel länger als die vorherige.++++

++++Tipp 2:|

   * Definiere eine Variable und setze sie auf einen Startwert (Länge der ersten Linie)
   * Addiere nun jedes Mal, nachdem du eine Linie gezeichnet hast, 10 zu dieser Variable.

++++

=== Aufgabe G6 ===

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

   * Frage Benutzer nach Anzahl M&M in der Tüte.
   * Frage Benutzer nach Anzahl Freunden.
   * Der Code gibt dann schön formatiert aus, wie viele M&M 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 ===

Zeichne mit einer Turtle die folgende Spirale:

{{:gf_informatik:spirale_rund.png?direct&200|}}

++++Tipps:|

   * Lege den Radius des Arcs in einer Variable fest.
   * Zeichne z.B. einen Viertelkreis.
   * Erhöhe die Radius-Variable um einen festen Betrag.
   * Wiederhole das ganze in einer Schleife.

++++

=== 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.
   * Das sorgt dafür, dass wir zwei ineinander verschachtelte Schleifen haben:
<code python>
repeat 6: # für 6 Quadrate
    ...
    repeat 4: # um einzelnes Quadrat zu zeichnen
        ...
    ...
</code>

++++

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

{{ :gf_informatik:programmieren_i_03_verzweigungen_while.pdf |Slides: Bedingungen & 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.

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

{{:gf_informatik:repeat_meme_02.jpg?direct&200|}}

==== 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 - aber mit while!

=== 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$.

===== - Endlosschleifen und Break =====

Eine While-Schleife wiederholt einen Codeblock solange, wie deren Bedingung erfüllt ist. Falls die Bedingung immer erfüllt ist, liegt eine **Endlosschleife** vor. 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 Benutzerin soll aufgefordert werden, die nerdigste Zahl der Welt (also $42$) einzugeben: "Gib die nerdigste Zahl der Welt ein". Sobald sie $42$ eingegeben hat, soll die Schleife abgebrochen und der Benutzerin gratuliert werden:

<code python>
while True:
    number = input("Gib die nerdigste Zahl der Welt ein")
    if number == 42:
        break
    else:
        print("Leider nicht, versuche es noch einmal")

print("Gratuliere, du hast die richtige Zahl, 42, 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 ausgegeben "Zugang verweigert". 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.


===== Zusatzaufgaben =====

Löse die Aufgaben so elegant wie möglich. Verwende z.B. wann immer möglich Schleifen.

==== Basic ====

=== Aufgabe: Wiederholen ===

Bart hat mal seine Carbonara wieder mit Rahm gekocht! Zur Strafe muss er 100x "Kein Rahm in die Carbonara!" schreiben. Da du ein Herz für Bart hast, möchtest du ihm helfen und ihm einen Code schreiben, der ihm die Arbeit abnimmt (auch wenn er seine Strafe eigentlich verdient hat).

{{:gf_informatik:carbonara_bart.png?400|}}


=== Aufgabe: 5er-Reihe ===

Gib alle Zahlen der 5er Reihe aus im Bereich $5,10,...,500$.

=== Aufgabe: Summe gerader Zahlen ===

Berechne die Summe aller gerader Zahlen von $2$ bis und mit $100$.

=== Aufgabe: Unendlicher Zähler ===

Im Sekundentakt soll herauf gezählt werden: $1,2,3,4,5,...$.
Um einen Delay von 1s einzubauen, gehe wie folgt vor:
<code python>
import time # importiere ganz oben im Code
...
time.sleep(1) # Befehl, dass für 1s soll pausieren
</code>


==== Anspruchsvoll ====

=== Aufgabe: Lord of the Rings ===

Erzeuge das folgende Bild auf clevere Art und Weise.

{{:gf_informatik:the_rings.png?400|}}

*Tipp:* Verwende zwei ineinander verschachtelte Schleifen.



===== 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 dem Lehrer.

++++Lösungen A|

=== Aufgabe A1 ===

<code python>
from gturtle import *
fritz = Turtle()
fritz.forward(200)
fritz.left(90)
fritz.forward(200)
fritz.left(90)
fritz.forward(200)
fritz.left(90)
fritz.forward(200)
</code>

=== Aufgabe A2 ===

<code python>
from gturtle import *
fritz = Turtle()
fritz.right(90)
fritz.forward(200)
fritz.left(120)
fritz.forward(200)
fritz.left(120)
fritz.forward(200)
</code>

=== Aufgabe A3 ===

<code python>
from gturtle import *
fritz = Turtle()
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
fritz.right(60)
fritz.forward(100)
</code>

=== Aufgabe A4 ===

<code python>

from gturtle import *
fritz = Turtle()

# Quadrat 1
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)

# Quadrat 2
fritz.setPos(-200,0)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
fritz.forward(100)
fritz.left(90)
</code>

++++


++++Lösungen B|

=== Aufgabe B1 ===

Quadrat:
<code python>
from gturtle import *

length = 150

turi = Turtle()

repeat 4:
    turi.forward(length)
    turi.left(90)
</code>

Dreieck:
<code python>
from gturtle import *

length = 150

turi = Turtle()
turi.right(90)

repeat 3:
    turi.forward(length)
    turi.left(120)
</code>

Sechseck:
<code python>
from gturtle import *

length = 150

turi = Turtle()

repeat 6:
    turi.forward(length)
    turi.left(60)
</code>

=== Aufgabe B2 ===

<code python>
from gturtle import *

length = 30

turi = Turtle()

repeat 10:
    turi.forward(length)
    turi.right(90)
    turi.forward(length)
    turi.left(90)
</code>


=== Aufgabe B3 ===

<code python>
from gturtle import *

turi = Turtle()

repeat 9:
    turi.forward(150)
    turi.left(160)
</code>

=== Aufgabe B2 ===

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

l = 100
repeat 4:
    fritz.forward(l)
    fritz.left(90)

fritz.setPos(200,0)
repeat 4:
    fritz.forward(l)
    fritz.left(90)
</code>

=== Aufgabe B3 ===

<code python>
from gturtle import *
fritz = Turtle()
 
# Quadrat 1
l = 100
repeat 4:
    fritz.forward(l)
    fritz.left(90)
 
# Quadrat 2
fritz.setPos(300,0)
l = 200
repeat 4:
    fritz.forward(l)
    fritz.left(90)
</code>

++++


++++Lösungen C|


=== Aufgabe C1 ===

<code python>
from gturtle import *

peter = Turtle()

length = 50
angle = 90
dot_size = 20

peter.right(45)

repeat 6:
    peter.dot(dot_size)
    peter.forward(length)
    peter.dot(dot_size)
    peter.right(angle)
    peter.forward(length)
    peter.left(angle)
</code>

=== Aufgabe C2 ===

<code python>
from gturtle import *

peter = Turtle()

radius = 30

peter.setPos(0,-200)

repeat 4:
    peter.rightArc(radius,180)
    peter.leftArc(radius,180)
</code>

=== Aufgabe C3 ===

<code python>
from gturtle import *

peter = Turtle()

radius_1 = 70
radius_2 = 2 * radius_1

peter.rightArc(radius_1,180)
peter.leftArc(radius_1,180)
peter.leftArc(radius_2,180)
</code>
Oder einfach:
<code python>
from gturtle import *

peter = Turtle()

radius = 70

peter.rightArc(radius,180)
peter.leftArc(radius,180)
peter.leftArc(2*radius,180)
</code>

++++


++++Lösungen D|

=== Aufgabe D1 ===

<code python>
from gturtle import *

clear("green")

peter = Turtle()
peter.setPenWidth(10)
length = 200

peter.setPenColor("red")
peter.forward(length)
peter.left(90)
peter.setPenColor("blue")
peter.forward(length)
peter.left(90)
peter.setPenColor("yellow")
peter.forward(length)
peter.left(90)
peter.setPenColor("magenta")
peter.forward(length)
peter.left(90)
</code>

=== Aufgabe D2 ===

<code python>
from gturtle import *

smiley = Turtle()
smiley.hideTurtle()

radius = 100
eyes = 30

# face
smiley.setPenWidth(5)
smiley.setPos(radius,0)
smiley.startPath()
smiley.leftArc(radius,360)
smiley.setFillColor("yellow")
smiley.fillPath()

# eyes
smiley.setPos(radius//3,radius//3)
smiley.dot(eyes)
smiley.setPos(-radius//3,radius//3)
smiley.dot(eyes)

# smile
smiley.setPos(radius//2,-radius//4)
smiley.left(180)
smiley.rightArc(radius//2,180)
</code>
=== Aufgabe D3 ===

<code python>
from gturtle import *

clear("black")

peter = Turtle()
peter.hideTurtle()

radius = 60
offset = 20

peter.setPenColor("white")
peter.setPenWidth(5)

# red
peter.setPos(0,2*radius + offset)
peter.setFillColor("red")
peter.startPath()
peter.leftArc(radius,360)
peter.fillPath()
# yellow
peter.setPos(0,0)
peter.setFillColor("yellow")
peter.startPath()
peter.leftArc(radius,360)
peter.fillPath()
# green
peter.setPos(0,-2*radius - offset)
peter.setFillColor("green")
peter.startPath()
peter.leftArc(radius,360)
peter.fillPath()
</code>

++++


++++Lösungen E|

=== Aufgabe E1 ===

In dieser Aufgabe braucht es keine Turtle.

<code python>
guess = input("Versuche, meine Lieblingszahl zu erraten!")

if guess == 7:
    print("Korrekt!")
else:
    print("Falsch! Warum weisst du das nicht?")
</code>


=== Aufgabe E2 ===

Version 1:

<code python>
from gturtle import *

chris = Turtle()

form = input("Gib q ein, um ein Quadrat zu zeichnen.")

if form == "q":
    repeat 4:
        chris.forward(100)
        chris.left(90)
else:
    print("Unzulässige Eingabe!")
</code>

Version 2:
<code python>
from gturtle import *

chris = Turtle()

form = input("Gib q (Quadrat) oder d (Dreieck) ein, um die Figur zu zeichnen.")
length = 100

if form == "q":
    repeat 4:
        chris.forward(length)
        chris.left(90)
if form == "d":
    chris.left(30)
    repeat 3:
        chris.forward(length)
        chris.left(120)
else:
    print("Unzulässige Eingabe!")
</code>



=== Aufgabe E3 ===

Keine Turtles hier!

<code python>
joke_number = input("Gib eine Witznummer 1-5 ein.")

if joke_number == 1:
    print("Was macht ein Pirat am Computer? Er drückt die Enter-Taste.")
elif joke_number == 2:
    print("Was macht ein Clown im Büro? Faxen.")
elif joke_number == 3:
    print("Was ist orange und läuft durch den Wald? Eine Wanderine.")
elif joke_number == 4:
    print("Was ist weiss und rollt den Berg hoch? Eine Lawine mit Heimweh.")
elif joke_number == 5:
    print("Warum können Bienen so gut rechnen? Weil sie den ganzen Tag mit Summen beschäftigt sind.")
</code>

=== Aufgabe E4 ===

<code python>
age = input("Wie alt bist du?")

if age >= 18:
    print("Volljährig.")
else:
    print("Minderjährig.")
</code>

=== Aufgabe E5 ===

<code python>
number = input("Gib eine Zahl ein")

if number > 0:
    print("positiv")
elif number == 0:
    print("Null")
else:
    print("negativ")
</code>

=== Aufgabe E6 ===

<code python>
nr_1 = input("Gib eine Zahl ein")
nr_2 = input("Gib eine zweite Zahl ein")

if nr_1 > nr_2:
    print(nr_1)
else:
    print(nr_2)
</code>

++++


++++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>
from gturtle import *

turi = Turtle()
turi.hideTurtle()

length = 50

repeat 32:
    turi.forward(length)
    turi.left(90)
    length = length + 10
</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>
from gturtle import *

turi = Turtle()
turi.hideTurtle()

length = 10

repeat 30:
    turi.leftArc(length,90)
    length = length + 5
</code>

=== Aufgabe G8 ===

<code python>
from gturtle import *

turi = Turtle()
turi.hideTurtle()

position = -200
radius = 30

repeat 10:
    turi.setPos(position,0)
    turi.leftArc(30,360)
    position = position + 2 * radius
</code>

=== Aufgabe G9 ===

<code python>
from gturtle import *

turi = Turtle()
turi.hideTurtle()

radius = 40
position = -300

repeat 6:
    turi.setPos(position,0)
    repeat 4:
        turi.forward(100)
        turi.left(90)
    position = position + 120
</code>

++++


++++Aufgaben H|

=== Aufgabe H1 ===

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

=== Aufgabe H2 ===

<code python>
countdown = 10
while countdown > 0:
    print(countdown)
    countdown = countdown - 1

print("Los!")
</code>

=== Aufgabe H3 ===

<code python>
from gturtle import *

turi = Turtle()

count = 0
while count < 4:
    turi.forward(150)
    turi.left(90)
    count = count + 1
</code>

=== Aufgabe H4 ===

<code python>
summe = 0

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

print(summe)
</code>

=== Aufgabe H5 ===

<code python>
# OPTION 1: mit zwei separaten Variablen
count = 0
number = 7

while count < 100:
    print(number)
    count = count + 1
    number = number + 7

# OPTION 2: mit nur einer Variablen
count = 0
while count < 100:
    count = count + 1
    print(7*count)
</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>


++++