Programmieren Teil 4

Diese Seite ist nicht editierbar. Du kannst den Quelltext sehen, jedoch nicht verändern. Kontaktiere den Administrator, wenn du glaubst, dass hier ein Fehler vorliegt.
====== Programmieren Teil 4 – Funktionen ======
  * Dieses Seite ist die Fortsetzung von [[gf_informatik:programmieren_iii_gra|]].
  * Weiter zu [[gf_informatik:programmieren_v_gra|]].



++++Lernziele:|
   - Ich beherrsche die in Teil 1 und 2 gelernten Grundlagen in python (Turtlegraphics, Variablen, while-Schleife, Verzweigungen, Vergleichsoperatoren, mathematische Operatoren, f-Strings, Funktionen ''print'' und ''input'', nie repeat verwenden, clever und kompakt programmieren).
   - Ich beherrsche den Umgang mit Listen, wie in Teil 3 gelernt:
     * Listen korrekt erstellen – leer oder mit Zahlen oder mit Texten drin.
     * Mit einer while-Schleife alle Elemente einer Liste durchgehen, sie auslesen/ausgeben oder mit einer if-Verzweigung abfragen und evtl. verändern oder entfernen.
     * Die Listen-Funktionen ''pop'' und ''append'' richtig verwenden.
     * Mit ''in'' fragen, ob ein bestimmtes Element in einer Liste vorkommt.
     * Listen analysieren (z.B. Mittelwert ermitteln) oder verändern (z.B. bestimmte Elemente ersetzen etc.).
   - Ich kann Funktionen mit und ohne Argumente definieren.
   - Ich kann Funktionen mit und ohne Rückgabewerte definieren.
   - Ich kann Funktoinen korrekt und sinnvoll aufrufen. Dabei achte ich darauf:
     - ...welche Argumente der Funktion übergeben werden und
     - ...was die Funktion zurückgibt.
   - Ich verstehe die Begriffe **Argument**, **Rückgabewert**, **Definition** und **Aufruf**.
   - Ich kann die logischen Operatoren ''and'', ''or'' und ''not'' korrekt verwenden.
   - Ich kann Mudule wie ''random'' oder ''math'' importieren und Funktionen daraus wie ''randint'' oder ''sqrt'' korrekt verwenden.
   - Ich beherrsche einfache String-Operationen (Texte erstellen, Texte zusammenfügen, auf bestimmte Buchstaben zugreifen).
   - Ich kann die Buchstaben eines Texts mithilfe einer while-Schleife durchgehen, sie auslesen/ausgeben oder mit einer if-Verzweigung abfragen.

++++

===== - Einführung =====
Du kennst Variablen – darin kannst du einen Wert speichern. Und du kennst Listen – darin kannst du mehrere Werte speichern. Aber du hast dich villeicht schon gefragt: <color #0433ff>"Was, wenn ich gleich mehrere Codezeilen irgendwo unterbringen will?"</color>. Für diese Idee gibt es **Funktionen**, die wir auch **Unterprogramme** nennen können.


=== Auftrag 1 – Bereits bekannte Funktionen anschauen ===
In Python sind viele Funktionen schon eingebaut. Du hast ein paar davon schon oft verwendet – zum Beispiel ''print'', ''input'' und ''len'':

<code python>
print("Hallo")
name = input("Wie heisst du?")
n_letters = len(name)
print(f"Dein Name hat {n_letters} Buchstaben.")
</code>

== Aufgabe ==
Zu zweit: Besprecht folgende Fragen. Vergleicht dann mit der Lösung unten.
  - Was ist allen drei Funktionen gemeinsam?
  - Worin unterscheiden sich die Funktionen //strukturell// (abgesehen davon, dass sie unterschiedliche Namen haben und unterschiedliche Zwecke erfüllen)? 

===== - Theorie =====

=== Auftrag 2 – Eine Funktion (ein Unterprogramm) erstellen und verwenden ===
Mit folgendem Code zeichnet die Turtle einen violeten Punkt, dreht 90 Grad nach rechts und fährt um 40 Pixel weiter:

<WRAP group>
<WRAP column twothirds>
<code python>
from gturtle import * 
karl = Turtle()

karl.setPenColor("purple")
karl.dot(40)
karl.right(90)
karl.forward(40)
</code>
</WRAP>

<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-122049.png?200}}
</WRAP>
</WRAP>

Die letzten vier Codezeilen aus obigem Code packen wir nun in eine Funktion namens "purple_dot". Dann rufen wir die Funktion viermal nacheinander auf:

<WRAP group>
<WRAP column twothirds>
<code python>
from gturtle import * 
karl = Turtle()

def purple_dot():
    karl.setPenColor("purple")
    karl.dot(40)
    karl.right(90)
    karl.forward(40)

purple_dot()
purple_dot()
purple_dot()
purple_dot()
</code>
</WRAP>

<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-122800.png?200}}
</WRAP>
</WRAP>

**Beachte:** 
  * Um eine Funktion zu erstellen, benötigst du das Schüsselwort ''def'' (die Funktion wird hier **def**iniert). 
  * Dann folgt der Funktionsname mit anschliessenden Klammern und ein Doppelpunkt:
    * alle Codezeilen, die nun eingerückt folgen, gehören zu dieser Funktion.
  * Du musst die Funktion erstellen, **bevor** du sie aufrufst. Die Definition der Funktion erfolgt also immer **oben im Code** und der Aufruf weiter unten.

== Aufgabe ==
<WRAP group>
<WRAP column twothirds>

Kopiere obigen Code mit der Funktion "purple\_dot" und verändere ihn wie folgt:

  * Die Funktion soll neu "blue\_dot" heissen.
  * Dein Code soll sechs blaue 20-Pixel-Punkte im Sechseck zeichnen: Siehe Bild:

</WRAP>

<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-130345.png?180}}

</WRAP>
</WRAP>

=== Auftrag 3 – Eine Funktion mit Argument erstellen und verwenden ===

Wir können einer Funktion auch ein **Argument** (oder mehrere) mitgeben. Argumente kommen **in die Klammern** rein. In folgendem Beispiel wird als Argument die Farbe übergeben.

<WRAP group>
<WRAP column twothirds>
<code python>
from gturtle import * 
karl = Turtle()

def my_dot(color):
    karl.setPenColor(color)
    karl.dot(40)
    karl.right(90)
    karl.forward(40)

my_dot("red")
my_dot("blue")
my_dot("orange")
my_dot("green")
</code>
</WRAP>

<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-145320.png?200}}
</WRAP>
</WRAP>

== Aufgabe ==
<WRAP group>
<WRAP column twothirds>

Kopiere obigen Code und verändere ihn wie folgt:

  * Die Funktion hat ein Argument namens dot_size. Es wird also die Grösse des Punkts mitgegeben.
  * Dein Code zeichnet vier purpurne(("crimson")) Punkte in den Grössen 20, 30, 40, 30, siehe Bild.

</WRAP>

<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-181230.png?200}}

</WRAP>
</WRAP>
=== Auftrag 4 – Eine Funktion mit Argumenten und Rückgabewert erstellen und verwenden ===
Folgende Funktion namens ''schnitt'' berechnet den Durchschnitt zweier Zahlen und gibt das Resultat zurück. Die Funktion wird unten in der Funktion ''print'' aufgerufen.((Der Rückgabewert der Funktion ''schnitt'' wird der Funktion ''print'' als Argument übergeben)).
<code python>
def schnitt(zahl1, zahl2):
    summe = zahl1 + zahl2
    return summe/2

print(schnitt(4, 5))
</code>

**Beachte:**
  * Das Schlüsselwort ''return'' bewirkt Folgendes:
    - Die Funktion wird sofort verlassen.
    - Die Funktion gibt den Wert zurück, der hinter ''return'' steht.
  * Wenn kein Wert hinter return steht, gibt die Funktion ''None'' (nichts) zurück.


== Aufgabe ==
Erstelle eine Funktion namens ''quader'' mit drei Argumenten namens ''l'', ''b'' und ''h'' für die Länge, Breite und Höhe des Quaders. Die Funktion gibt das Volumen des Quaders zurück. Beispiel: Der Aufruf ''quader(2, 3, 4)'' gibt **24** zurück. Teste die Funktion, indem du sie **dreimal** mit unterschiedlichen Argumenten aufrufst und das Resltat jeweils mit ''print'' ausgibst. 

=== Auftrag 5 – Wichtige Begriffe erklären ===
Besprecht zu zweit die folgenden Fragen zu Funktionen. Vergleicht anschliessend mit den Lösungen unten. Lest diese //genau// und fragt bei Bedarf nach!
  - Was ist ein **Argument**?
  - Was ist ein **Rückgabewert**? Welches Schüsselwort ist hier wichtig?
  - Was ist eine **Definition**? Welches Schösselwort ist hierzu nötig?
  - Was ist ein **Aufruf**?


===== - Aufgaben N – Funktionen =====
In folgenden Aufgaben sollst du Funktionen erstellen (= definieren) und verwenden (=aufrufen).

==== Aufgaben NA – Einfache Funktionen (Unterprogramme) ohne Rückgabewerte ====
Die folgenden Aufgaben behandeln Funktionen mit und ohne Argumente – aber ohne Rückgabewerte.

=== NA1 – Blumen ===
Schreibe eine Funktion namens ''blume()'', die die Turtle eine Blume wie im Bild unten zeichnen lässt. Rufe die Funktion dreimal auf. Verändere zwischen den Aufrufen die Position der Turtle, soass drei Blumen an unterschiedlichen Orten gezeichnet werden, siehe Bild:

{{:gf_informatik:programmieren_iv_gra:pasted:20250429-194213.png?200}}

Hinweis: Eine Blume wie im Bild kann aus sechs 30-px-Punkten (''dot'') auf einem Kreis (''rightArc'' oder ''leftArc'') mit Radius 20 gezeichnet werden.

=== NA2 – Bunte Blumen ===
Ändere die Funktion ''blume'' aus NA1 so, dass als Argument die Farbe der Blume übergeben werden kann. Rufe die Funktion viermal auf – jedesmal mit anderer Farbe. Verändere zwischen den Aufrufen die Position der Turtle, soass drei Blumen an unterschiedlichen Orten gezeichnet werden, siehe Bild:

{{:gf_informatik:programmieren_iv_gra:pasted:20250430-050227.png?220}}

=== NA3 – Blumenreihen ===
== Schritt 1 ==
Ändere die Funktion ''blume'' aus NA2 so, dass neben der Farbe auch die X- und die Y-Position der Blume übergeben werden kann: Also ''blume(color, xpos, ypos)''. Wenn du dann folgenden Code ergänzt, sollten sechs rote Blumen in einer Reihe (wie im Bild unten) gezeichnet werden:
<code python>
x = 0
while x < 600:
    blume("red", x, 0)
    x = x + 100
</code>

{{:gf_informatik:programmieren_iv_gra:pasted:20250430-124125.png?300}}

== Schritt 2 ==
Lösche den vorhin ergänzten Code (die vier Zeilen mit der while-Schleife) und füge stattdessen folgende Codezeilen unterhalb deiner Funktion ''blume'' ein:
<code python>
colors = ["orange", "purple", "blue", "crimson", "pink", "violet"]
xpositions = [0,55,105,145,200,225]
ypositions = [0,25,-10,25,50,10]
</code>

Schreibe einen möglichst kurzen Code mit while-Schleife, der sechs Blumen anhand der Werte in den drei Listen zeichnet. Es sollte folgendes Bild entstehen:

{{:gf_informatik:programmieren_iv_gra:pasted:20250502-074916.png?200}}

=== NA4 – Wer hat die schönste Blumenwiese? ===

<WRAP group>
<WRAP column twothirds>
Nutze deine Funktion ''blume'', der du Farbe, X- und Y-Position übergeben kannst. Erstelle ein Bild aus mindestens 20 zufällig angeordneten Blumen mit zufälliger Farbe – zum Beispiel wie das Bild rechts. Beachte folgende Hinweise: 
  * Die Hintergrundfarbe kannst du mit der Turtle-Funktion ''clear'' festlegen: z.B. ''flori.clear("gray")''.
  * Die Farbcodes finden sich [[https://trinket.io/docs/colors|hier]]: Übernehme jeweils den ''Turtle name'' **ohne Abstände**.
  * Erstelle eine Liste mit verschiedenen Farbnamen. Daraus wählst du später für jede Blume ein zufälliges Element.
  * Wähle die x-Positionen im Bereich -250 bis 250, und die y-Positionen im Bereich -100 bis 100, sodass ein Bild im Breitformat entsteht.
  * Mit der Funktion ''hideTurtle'' zeichnet deine Turtle sehr schnell.

</WRAP>

<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250502-083126.png?300}}
</WRAP>
</WRAP>



<color #22b14c>**Wettbewerb: Sende dein schönstes Blumenbild via Teams der LP und nimm an der Wahl zur schönsten Blumenwiese teil!** </color>


==== Aufgaben NB – Funktionen (Unterprogramme) mit Rückgabewerten ====
Die folgenden Aufgaben behandeln Funktionen mit Argumenten und Rückgabewerten.
=== NB1 – Franken in Kronen ===
Schreibe eine Funktion ''chf\_in\_nok'', die Schweizer Franken (CHF) in Norwegische Kronen (NOK) umrechnet. Der Funktion wird eine Zahl in CHF übergeben und sie gibt die richtige Zahl in NOK zurück. Für den Umrechnungsfaktor googelst du einfach nach "chf in nok".
Teste deine Funktion.

=== NB2 – Maximalwert aus zwei Zahlen ===
Schreibe eine Funktion ''max\_von\_zwei(a, b)'', die das grössere der beiden Argumente zurückgibt. Teste deine Funktion für beide Fälle (erstes Argument grösser und zweites Argument grösser).

=== NB3 – Pfannkuchen ===
<WRAP group>
<WRAP column twothirds>
Schreibe eine Funktion ''zutaten\_pfannkuchen(personen)'', die ausgehnd von der Anzahl Personen die Mengen für die Zutaten Mehl, Salz, Milch und Eier berechent und zurückgibt.
Hier die Mengen für eine Person:
  * 50 g Mehl
  * 0.125 Teelöffel Salz
  * 1 dl Milch
  * 1 Ei
**Hinweis:** Hinter ''return'' kannst du mehrere Rückgabewerte anführen: Trenne sie mit Kommas.

Teste deine Funktion mit folgendem Code:

</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250507-053931.png?270}}
</WRAP>
</WRAP>

<code python>
n = input("Wie viele Personen?")
mehl, salz, milch, ei = zutaten_pfannkuchen(n)
print(f"Du brauchst:\n{mehl} g Mehl\n{salz} TL Salz\n{milch} dl Milch\n{ei} Eier")
</code>

=== NB4 – Minimalwert aus drei Zahlen ===

<box 100% round green|**Logische Verknüpfungen**>

Mit den Schlüsselworten ''and'' und ''or''kannst du Bedingungen miteinander **verknüpfen**. Mit dem Schlüsselwort ''not'' kannst du Bedingungen und Ausdrücke **invertieren**. Hier drei Beispiele:

<code python>
a = input("Erste Zahl eingeben:")
b = input("Zweite Zahl eingeben:")

if a > 0 and b > 0:
    print("Beide Zahlen sind positiv")

if a > 0 or b > 0:
    print("Mindestens eine der Zahlen ist positiv")

if not(a > 0 or b > 0):
    print("Keine der Zahlen ist positiv")
</code>

  * Erste Verzweigung: Eine Verknüpfung mit ''and'' ist wahr, wenn **sowohl** die erste, **als auch** die zweite Bedingung wahr ist.
  * Zweite Verzweigung: Eine Verknüpfung mit ''or'' ist wahr, wenn die erste **oder** die zweite Bedingung **oder** beide wahr sind.
  * Dritte Verzweigung: ''not'' invertiert (negiert) die nachfolgende Bedingung: Wenn das, was nach ''not'' kommt, falsch ist, so ist die gesamte Bedingung wahr – und umgekehrt.

[[https://webtigerpython.ethz.ch/?code=NobwRAdghgtgpmAXGGUCWEB0AHAnmAGjABMoAXKJMKAAgF4aNsBXMgCgB0wBRAJwGcycGgC0oACwA2NOBgDmcAEZwIiLgEoOERfUYQW7LiIDusoaInTZEBctUatWtADMatAHw0ADG4jEaOp5eahA0YTTYvBiGYABCssTCYlIqNPwY_tgA9ulkaABuDhBOrh7eNFm8ATRBIeERURAxALIZcIIq_DIYwolVyZKpaIIROWh5hWCaxRAuNBBZ7GU-ldVB6nXhkdGcYADS1r1w_ZZDI9m5BUVgAL4AukA|Probiere es aus – teste den Code für alle drei Möglichkeiten!]]

</box>

Schreibe eine Funktion ''min\_von\_drei(a, b, c)'', die das kleinste der drei Argumente zurückgibt. Verwende **logische Verknüpfungen** (studiere hierzu die grüne Box oben).  Teste deine Funktion mit folgendem Code:

<code python>
print(min_von_drei(1,2,3))
print(min_von_drei(5,6,4))
print(min_von_drei(9,7,8))
</code>

=== NB5 – Maximalwert aus Liste ===
Schreibe eine Funktion ''max\_in\_liste(liste)'', die das grösste Element aus einer Liste zurückgibt. Verwende eine Schleife. Verwende keine bestehende Funktion. Teste deine Funktion mit folgenden drei Listen:

<code python>
list1 = [11, 16, 5, 12, 3, 13] 
list2 = [13, 2, 5, 10, 1, 17, 5, 25]
list3 = [-25, -13, -3, -33]
</code>

=== NB6 – Gerade oder ungerade ===
Schreibe eine Funktion ''ist\_gerade(n)'', die ''True'' zurückgibt, wenn n gerade ist, sonst ''False''. Teste deine Funktion mit folgendem Code:

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

if ist_gerade(zahl):
    print("Die Zahl ist gerade")
else:
    print("Die Zahl ist ungerade")
</code>

**Frage:** Bisher hatten wir in einer if-Verzeigung immer eine Bedingung mit Vergleichsoperatoren stehen. Zum Beispiel //x > 4// oder //x % 2 == 0// etc. In diesem Code steht bloss die Funktion ist_gerade(). Wie erklärst du, dass hier keine Bedingung nötig ist? Bespreche deine Antwort mit der Lehrperson.

=== NB7 – Pizzabestellung ===

<WRAP group>
<WRAP column twothirds>

Schreibe eine Funktion ''pizza\_lieferung(n)'', die ausgehend von der Anzahl Pizzen den Preis für die Pizzalieferung berechnet und zurückgibt. Das Argument ''n'' gibt die Anzahl Pizzen an. Jede Pizza kostet 12 Franken. Die Liefergebühren betragen 20 Franken. Ab einem Bestellwert von 50 Franken entfallen die Liefergebühren. Teste deine Funktion.

</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250507-061750.png?200}}
</WRAP>
</WRAP>

**Frage:** Wenn ihr zu viert seid: Bestellt ihr besser 4 oder 5 Pizzen?

=== NB8 – Nächte im Hotel ===

<WRAP group>
<WRAP column twothirds>
Schreibe eine Funktion ''hotel\_preise(personen, naechte, klasse)'', die den Gesamtpreis für einen Hotelaufenthalt gemäss folgender Tabelle berechnet und zurückgibt:
Preise **pro Nacht**:
^ Klasse    ^ Einzelzimmer  ^ Doppelzimmer  ^
| Standard  | 120           | 160           |
| Ausblick  | 140           | 180           |
| Balkon    | 200           | 260           |

**Hinweise:** 
  * Deine Funktion muss zuerst die Anzahl Einzel- und Doppelzimmer berechnen (ausgehend von der Anzahl Personen): Es ist maximal ein Einzelzimmer nötig.
  * Falls für die Klasse etwas anderes als "Standard", "Ausblick" oder "Balkon" angegeben wird, wird der höchste Preis (Balkon) berechnet.

</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250507-120048.png?270}}
</WRAP>
</WRAP>

Teste deine Funktion mit folgendem Code:
<code python>
# Reise 1: 2 Personen, 2 Nächte, Standard: Preis = 320
print(hotel_preise(2, 2, "Standard"))
# Reise 2: 5 Personen, 3 Nächte, Ausblick: Preis = 1500
print(hotel_preise(5, 3, "Ausblick"))
# Reise 3: 6 Personen, 4 Nächte, Balkon: Preis = 3120
print(hotel_preise(6, 4, "Balkon"))
# Reise 4: 1 Person, 1 Nacht, falsche Angabe: Preis = 200
print(hotel_preise(1, 1, "stanDart"))
</code>


==== Aufgaben NC – Gemischte Aufgaben zu Funktionen ====
Die folgenden Aufgaben behandeln Funktionen mit und ohne Argumente oder Rückgabewerte.


=== NC1 – Hexagons are the Bestagons ===
  - Schreibe eine Funktion ''hexagon()'', die deine Turtle ein Sechseck zeichnen lässt. 
  - Verwende anschliessend  diese Funktion in einer while-Schleife, um sechs Sechsecke zu zeichnen, sodass in der Mitte ein siebtes entsteht (Siehe Bild).

{{:gf_informatik:programmieren_iv_gra:pasted:20250419-100942.png?300}}

Wenn du das geschafft hast, darfst du folgendes Video schauen: [[https://youtu.be/thOifuHs6eY?si=yKl7z6uLPcnUuNi6|Hexagons are the Bestagons]].

=== NC2 – Random Dots ===
{{:gf_informatik:programmieren_iv_gra:pasted:20250514-084206.png?500}}
  - Schreibe eine Funktion ''punkte(min, max, farben)'' gemäss folgenden Anforderungen:
    - Die Argumente ''min'' und ''max'' geben an, wie viele Punkte mindestens und höchstens gezeichnet werden.
    - Das Argument ''farben'' ist eine **Liste** mit Farbnamen. 
    - Die Funktion zeichnet eine zufällige Anzahl Punkte (20 px) im gewünschten Bereich.
    - Für jedem Punkt wird eine zufällige Farbe aus der Farbliste gewählt.
    - Die Position jedes Punktes wird ebenfalls zufällig bestimmt: Die x-Position im Bereich -250 bis 250, die y-Position im Bereich -100 bis 100.
    - **Die Funktion gibt zurück, wie viele Punkte sie gezeichnet hat.**
  - Schreibe ein Programm, das die Funktion ''punkte'' verwendet:
    - Erstelle eine Liste mit vier bis sieben Farben.
    - Rufe die Funktion auf (mit beliebigen Werten für min und max sowie mit der Farbliste) und gib eine Meldung in folgender Form aus: "Es wurden 14 Punkte gezeichnet".
=== NC3 – Crimson & Clover ===
Crimson & Clover ist der Titel [[https://youtu.be/-wXJ1WN3GR4?si=ngF7kK59Rw1MqoYx|dieses Liedes]] von Tommy James and the Shondells.

{{:gf_informatik:programmieren_iv_gra:pasted:20250508-195423.png?300}} {{:gf_informatik:programmieren_iv_gra:pasted:20250508-195521.png?210}}


== Schritt 1 – Herzblatt ==
<WRAP group>
<WRAP column half>
Schreibe eine Funktion ''herzblatt(seite, farbe)'', die ein farbiges Herzblatt gemäss der Zeichnung rechts malt: 
  * Das Argument ''seite'' bestimmt die Seitenlänge des Quadrats im Herzblatt.
  * Das Argument ''farbe'' bestimmt die Farbe des Herzblatts. 
  * Verwende die Turtle-Funktionen ''setFillColor(color)'', ''startPath()'' und ''fillPath()''. 
  * Teste die Funktion.

</WRAP>
<WRAP column quater>

{{:gf_informatik:programmieren_iv_gra:pasted:20250508-100926.png?150}}

</WRAP>
<WRAP column quater>
{{:gf_informatik:programmieren_iv_gra:pasted:20250509-060712.png?150}}

</WRAP>
</WRAP>

== Schritt 2 – Kleeblätter ==
<WRAP group>
<WRAP column half>
Schreibe eine weitere Funktionen ''kleeblatt3(radius)'', die ein <color #008000>grünes</color>, dreiblättriges Kleeblatt malt.
  * Verwende die eben erstellte Funktion herzblatt.
  * Das Argument ''radius'' bestimmt den (inneren) Radius, du kannst es einfach an die Funktion ''herzblatt'' weitergeben.
  * Teste die Funktion.

Wiederhole Schritt 2 für eine Funktion ''kleeblatt4(radius)'', die ein <color #006400>dunkelgrünes</color>, vierblättriges Kleeblatt malt.

</WRAP>
<WRAP column quater>
{{:gf_informatik:programmieren_iv_gra:pasted:20250508-200449.png?150}}
</WRAP>
<WRAP column quater>
{{:gf_informatik:programmieren_iv_gra:pasted:20250509-060512.png?150}}
</WRAP>
</WRAP>

== Schritt 3 – Crimson & Clover ==
<WRAP group>
<WRAP column half>
Schreibe ein Programm, das die Kleeblatt-Funktionen verwendet und eine zufällige Wiese aus ingesamt 30 Purpur-Punkten und Kleeblättern malt, ähnlich dem Bild rechts: 
  * Jede siebte Figur ist ein vierblättriges Kleeblatt.
  * Jede dritte Figur ist dreiblättriges Kleeblatt.
  * Alle anderen Figuren sind Purpur-Punkte.
  * Die Grösse jedes Kleeblatts oder Punktes wird jeweils zufällig bestimmt.
  * Beachte die Hinweise in Aufgabe NA4.
</WRAP>

<WRAP column half>
{{:gf_informatik:programmieren_iv_gra:pasted:20250509-060413.png?300}}
</WRAP>
</WRAP>

== Zusatzaufgabe (Optional) ==
<WRAP group>
<WRAP column half>

Verbessere deine Herzblatt-Funktion: ''herzblatt2(seite, farbe1, farbe2)'' soll ein //zweifarbiges// Herzblatt zeichnen. Wie im nebenstehenden Bild. 
  * Um ein Herz auf diese Weise zu zeichnen, benötigst du die Funktion ''sqrt()'', die die Quadratwurzel (square root) aus einer Zahl ermittelt. Hierzu musst du das Modul ''math'' importieren:
<code python>
import math
print(math.sqrt(4))
</code>
</WRAP>

<WRAP column half>
{{:gf_informatik:programmieren_iv_gra:pasted:20250509-101538.png?250}}
</WRAP>
</WRAP>
=== NC4 – Text rückwärts ===

<box 100% round green|**Strings vs. Listen**>

**Texte** werden in python als **Strings** (engl. "Schnur" oder "Kette") bezeichnet. Ein Text besteht aus mehreren Buchstaben und ist damit eine Aneinanderreihung von Buchstaben – sozusagen eine //Kette// von Buchstaben. 

**Strings** haben gewisse Ähnlichkeit mit **Listen**: Auch in Listen sind mehrere Elemente aneinander gehängt. Hier  vergleichen wir Listen mit Strings anhand einiger Befehle/Operationen:

<WRAP group>
<WRAP column half>
Befehle mit Listen:
<code python>
my_list = [] # Leere Liste erstellen
numbers = [3,9,27] # Liste mit Inhalt erstellen
numbers.append(81) # Der Liste ein Element anfügen
n = numbers[2] # Bestimmtes Element in Liste wählen
print(n) # Gibt 27 aus
</code>

</WRAP>
<WRAP column half>
Befehle mit Strings:
<code python>
my_text = "" # Leeren Text erstellen
name = "Immanuel" # Text mit Inhalt erstellen
name = name + " Kant" # Dem Text einen Text anfügen
b = name[5] # Bestimmten Buchstaben im Text wählen
print(b) # Gibt 'u' aus
</code>

</WRAP>
</WRAP>

Die Funktion ''len()'' funktioniert sowohl für Listen als auch für Strings.


</box>

Schreibe eine Funktion ''text\_reverse(text)'', die einen Text rückwärts zurückgibt: 
  * Zum Beispiel soll der Aufruf ''text\_reverse("Roti Rösli im Garte")'' den Text "etraG mi ilsöR itoR" zurückgeben.
  * **Verwende eine While-Schleife**, um durch den String (den Text) zu gehen. 
    * Hinweis: Python böte mit der [[https://www.w3schools.com/python/gloss_python_string_slice.asp|String-Slicing-Syntax]] eine sehr kurze Lösung für diese Aufgabe. Wir verzichten hier aber auf String Slicing und bleiben vorerst bei der guten alten while-Schleife.
  * Teste deine Funktion.

=== NC5 – Abstände ersetzen ===
Schreibe eine Funktion ''replace\_spaces(text, char)''. Die Funktion ersetzt alle Abstände (spaces) in ''text'' durch das Zeichen ''char'' und gibt den neuen Text zurück. Zum Beispiel gibt der Aufruf ''replace\_spaces("Roti Rösli im Garte", '-')'' den Text "Roti-Rösli-im-Garte" zurück. Teste deine Funktion.
  * Hinweis: Mit eckigen Klammern können wir zwar einen Buchstaben aus einem String //auslesen//. Anders als bei Listen können wir die eckigen Klammern aber nicht nutzen, um einen bestimmten Buchstaben eines Strings zu verändern.


=== NC6 – Wörter rückwärts (Challenge) ===
Schreibe eine Funktion ''words\_reverse(text)'', die die Wortfolge eines Textes umdreht und den neuen Text zurückgibt. Zum Beispiel soll der Aufruf words\_reverse("Roti Rösli im Garte") den Text "Garte im Rösli Roti" zurückgeben.

== Schritt 1 ==
Schreibe zuerst eine Funktion ''word\_list(text)'', die jedes einzelne Wort in ''text'' in einer Liste auflistet und diese Liste zurückgibt. Teste die Funktion.

== Schritt 2 ==
Schreibe nun die Funktion ''words\_reverse(text)'' mithilfe der Funktion ''word\_list(text)''. Teste die Funktion.

===== - Aufgaben O – Funktionen für Fortgeschrittene =====
=== O1 – Weitere Nächte im Hotel ===

<WRAP group>
<WRAP column twothirds>
Schreibe eine neue Funktion ''hotel\_preise2(personen, naechte, anreisetag)'', die den Gesamtpreis für einen Hotelaufenthalt berechnet und zurückgibt:
Preise **pro Nacht**:
^ Tarif (Anreisetag)      ^ Einzelzimmer  ^ Doppelzimmer  ^
| Sonntag bis Donnerstag  | 120           | 140           |
| Freitag und Samstag     | 150           | 200           |

</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250508-071652.png?220}}
</WRAP>
</WRAP>
**Hinweise:** 
  * Deine Funktion muss zuerst die Anzahl Einzel- und Doppelzimmer berechnen (ausgehend von der Anzahl Personen): Es ist maximal ein Einzelzimmer nötig.
  * Die Angabe des Anreisetags erfolgt als Text, z. B. "Freitag", siehe Code unten.
  * Erstelle in der Funktion eine Liste ''tage'' mit Texten für jeden Wochentag. Mit der Funktion ''index'' kannst du die Position eines gegebenen Wochentags ermitteln, z.B. gäbe ''tage.index("Dienstag")'' den Wert **1** zurück.
  * Wenn du die Position des Anreisetag weisst, kannst du für jede Nacht beurteilen, ob Wochenendtarif gilt oder nicht – aber wie? Versuche es erst ohne Hilfe von KI. 

Teste deine Funktion mit folgendem Code:
<code python>
# Reise 1: 2 Personen, 2 Nächte ab Freitag: Preis = 400
print(hotel_preise2(2, 2, "Freitag"))
# Reise 2: 3 Personen, 4 Nächte ab Mittwoch: Preis = 1220 
print(hotel_preise2(3, 4, "Mittwoch"))
# Reise 3: 1 Person, 10 Nächte ab Donnerstag: Preis = 1320
print(hotel_preise2(1, 10, "Donnerstag"))
</code>

=== O2 – RGB-Palette ===
  - Schreibe eine Funktion ''rgb\_dot(red, green, blue)'', die einen Punkt in der gewünschten Farbe zeigt. 
    * Die drei Argumente können jeweils einen Wert zwischen 0 und 5 einnehmen: 
    * ''rgb\_dot(0,0,0)'' soll einen schwarzen Punkt zeichnen, 
    * ''rgb\_dot(5,0,0)'' einen ganz roten Punkt und 
    * ''rgb\_dot(5,5,5)'' einen weissen Punkt.
  - Ergänze einen Code, der alle 216 Farben, die mit dieser Funktion gezeichnet werden können, in einer Farbpallete wie im Bild unten aufzeichnet.
{{:gf_informatik:programmieren_iv_gra:pasted:20250508-075047.png}}
  * In jedem der sechs Quadrate nimmt der Blau-Anteil jeweils von links nach rechts und der Grün-Anteil von oben nach unten zu. 
  * Über die sechs Quadrate hinweg nimmt der Rot-Anteil von links nach rechts zu.

=== O3 – Fibonacci-Spirale ===
<WRAP group>
<WRAP column twothirds>
Infomiere dich zuerst über die Informiere dich über die [[https://de.wikipedia.org/wiki/Fibonacci-Folge|Fibonacci-Folge]] und erstelle dann Funktionen, mit denen Du eine Fibonacci-Spirale wie im Bild malen kannst.
  - Erstelle eine Funktion ''fibonacci(n)'', die eine Liste mit den ersten ''n'' Zahlen der Fibonacci-Folge zurückgibt. Zum Beispiel gibt ''fibonacci(7)'' die Liste ''[0, 1, 1, 2, 3, 5, 8]'' zurück. Teste die Funktion.
  - Erstelle eine Funktion ''viertelrkreis(radius, farbe)'', die einen Viertelkreis in gewünschter Farbe zeichnet. **Tipp:** Die Turtle sollte den Kreis so zeichnen, dass sie mit dem Bogen beginnt und am Ende an derjenigen Position ist, an der der nächste Kreisbogen beginnen kann. Teste deine Funktion, indem du sie mehrmals, mit immer grösserem Radius, aufrufst.
  - Erstelle eine Funktion ''fibo\_spirale(n)'', die eine fibonacci-Spirale aus ''n'' Viertelkreisen wie im Bild malt: Die Farben der Viertelkreise wechseln zwischen <color #0000FF>blau</color> und <color #FF0000>rot</color>. Verwende die bereits erstellten Funktionen ''fibonacci'' und ''viertelkreis''. Teste deine Funktion.
</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250516-100248.png?330}}
</WRAP>
</WRAP>

<WRAP group>
<WRAP column twothirds>
== Zusatzaufbabe ==
Erstelle eine neue Funktion ''fibo\_spirale2(n, colors)''. Dieser Funktion wird zusätzlich eine Farbliste beliebiger Länge mitgegeben. Die Funktion zeichnet die Viertelkreise gemäss der Farbliste. Für folgenden Code sollte nebenstehendes Bild entstehen.
<code python>
farben = ["crimson", "orange", "maroon", "gold"]
fibo_spirale2(9, farben)
</code>
</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250517-095040.png?330}}
</WRAP>
</WRAP>


=== O4 – Siebensegment-Anzeige ===
<WRAP group>
<WRAP column twothirds>
Die [[https://en.wikipedia.org/wiki/Seven-segment_display|Siebensegmentanzeige]] ist grossartig: Man benötigt nur 7 längliche Lämpchen und kann damit nicht nur die Ziffern 0 bis 9, sondern auch viele Buchstaben anzeigen! In dieser Aufgabe soll deine Turtle als Siebensegmentanzeige funktionieren.

{{:gf_informatik:programmieren_iv_gra:pasted:20250522-080927.png?600}}
</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250521-190507.png?200}}
</WRAP>
</WRAP>

<WRAP group>
<WRAP column twothirds>
== Schritt 1 – Einzelnes Segment zeichnen ==
Erstelle eine Funktion ''segment(length, color)''. Die Funktion zeichnet ein einzelnes Segment, das auf beiden Seiten spitz ausläuft – siehe Bild.
  * Das Argument ''length'' gibt die Länge des Segments von Spitz zu Spitz an. Damit genau diese Länge zustande kommt, musst du etwas rechnen. Eventuell brauchst du die Funktion ''sqrt'' und hierzu das Math-Modul (''import math'').
  * Das Argument ''color'' gibt die Farbe des Segments an.
  * Starte bei der einen Spitze und gehe davon aus, dass die Turtle in Richtung der anderen Spitze schaut, siehe Bild.
</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250521-191805.png?200}}
</WRAP>
</WRAP>

<WRAP group>
<WRAP column twothirds>
== Schritt 2 – Codes definieren ==
Im Bild rechts sind die 7 Segmente mit den Buchstaben A bis G bezeichnet. Den Dezimalpunkt lassen wir ausser Acht. Für die Ziffern **0** und **4** müssten die Segmente gemäss folgender Tabelle leuchten:
^  Ziffer  ^  A  ^  B  ^  C  ^  D  ^  E  ^  F  ^  G  ^  Binär-String   ^
|  0       |  1  |  1  |  1  |  1  |  1  |  1  |  0  |  ''"1111110"''  |
|  4       |  0  |  1  |  1  |  0  |  0  |  1  |  1  |  ''"0110011"''  |

  * Erstelle eine Liste ''binary\_strings[]'', die für jede Ziffer 0...9 den richtigen Binär-String enthält.

== Schritt 3 – Zahl mit 7 Segmenten anzeigen ==
Erstelle eine Funktion ''seven\_seg(number)''. Die Funktion zeichnet die 7 Segmente A bis G an den richtigen Positionen und in richtiger Farbe:
  * Verwende die bereits erstellte Funktion ''segment''.
  * Speichere für jedes Segment die x-Positionen, die y-Positionen und die Richtungen (heading) in Listen.
  * Das Argument number gibt an, welche Ziffer dargestellt werden soll. Verwende deine Liste ''binary\_strings[]'', um für jedes Segment zu entscheiden, ob es rot oder grau "gainsboro" sein soll.
  * Teste deine Funktion mit einem Programm, dass die Zahlen von 0 bis 9 im Sekundentakt (''delay(1000)'') hochzählt.
</WRAP>
<WRAP column third>
{{:gf_informatik:programmieren_iv_gra:pasted:20250521-191333.png?200}}
</WRAP>
</WRAP>

== Zusatzaufgaben ==
  * Programmiere eine zweistellige Anzeige, die von 0 bis 99 zählen kann.
  * Programmiere eine digitale Uhr, die die aktuelle Zeit in Stunden, Minuten und Sekunden (von Doppelpunkten getrennt) anzeigt.

===== - 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 zu den Aufträgen (Einstieg und Theorie)|

=== Auftrag 1 ===
  - Alle Funktionen haben Klammern.
  - Die Funktionen ''input'' und ''len'' geben einen Wert zurück, den wir im Code verwenden wollen und deshalb in einer Variable speichern. Von ''print'' erwarten wir üblicherweise keinen Rückgabewert.

=== Auftrag 2 ===
<WRAP group>
<WRAP column half>
Variante 1
<code python>
from gturtle import * 
karl = Turtle()

def blue_dot():
    karl.setPenColor("blue")
    karl.dot(20)
    karl.right(60)
    karl.forward(20)

blue_dot()
blue_dot()
blue_dot()
blue_dot()
blue_dot()
blue_dot()
</code>
</WRAP>

<WRAP column half>
Variante 2

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

def blue_dot():
    karl.setPenColor("blue")
    karl.dot(20)
    karl.right(60)
    karl.forward(20)

count = 0
while count < 6:
    blue_dot()
    count = count + 1
</code>
</WRAP>
</WRAP>

=== Auftrag 3 ===

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

def my_dot(dot_size):
    karl.setPenColor("crimson")
    karl.dot(dot_size)
    karl.right(90)
    karl.forward(40)

my_dot(20)
my_dot(30)
my_dot(40)
my_dot(30)
</code>

=== Auftrag 4 ===

<code python>
# Funktion erstellen:
def quader(l, b, h):
    return l * b * h

#Funktion dreimal aufrufen und Resultat ausgeben:
print(quader(2,3,4))
print(quader(3,3,3))
print(quader(4,5,5))
</code>

=== Auftrag 5 ===

  - Ein **Argument** ist das, was der Funktion //übergeben// oder //mitgegeben// wird. Es wird in die **Klammern** der Funktion geschrieben. Eine Funktion kann eines, mehrere oder gar kein Arugment haben. Wenn sie kein Argument hat, bleiben die Klammern leer. Als Argumente können Zahlen, Texte, Variablen oder Listen übergeben werden.
  - Ein **Rückgabewert** ist das, was die Funktion //zurückgibt//. Eine Funktion kann einen, mehrere oder gar keinen Rückgabewert haben. In der Defintion der Funktion schreibst du den Rückgabewert hinter das Schlüsselwort ''return''. Wenn du die Funktion aufrufst, steht der Rückgabewert dort, wo die Funktion steht. Ist dir das klar? Falls nicht: Lehrperson fragen!
  - In der **Defintion** erstellst du die Funktion. Hierzu benötigst du das Schlüsselwort ''def'', gefolgt vom Funktionsnamen, runden Klammern und einem Doppelpunkt. In den folgenden eingerückten Zeilen //definierst// du den Code, der ausgeführt wird, wenn die Funktion aufgerufen wird.
  - Im **Aufruf** rufst du die Funktion auf. Eine bereits definierte oder bekannte Funktion kannst du beliebig oft aufrufen.

++++
</nodisp>

<nodisp 1>
++++Lösungen zu Aufgaben NA:|
=== NA1 ===
<code python>
from gturtle import *
flori = Turtle()

def blume():
    flori.setPenColor("crimson")
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1

blume()
flori.setPos(60,60)
blume()
flori.setPos(100,-20)
blume()
</code>

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

def blume(color):
    flori.setPenColor(color)
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1

blume("blue")
flori.setPos(60,60)
blume("violet")
flori.setPos(80,-20)
blume("orange")
flori.setPos(140, 30)
blume("purple")
</code>

=== NA3 – Schritt 1 ===
<code python>
from gturtle import *
flori = Turtle()

def blume(color, xpos, ypos):
    flori.setPenColor(color)
    flori.setPos(xpos, ypos)
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1
x = 0
while x < 600:
    blume("red", x, 0)
    x = x + 100
</code>

=== NA3 – Schritt 2 ===
<code python>
from gturtle import *
flori = Turtle()

def blume(color, xpos, ypos):
    flori.setPenColor(color)
    flori.setPos(xpos, ypos)
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1

colors = ["orange", "purple", "blue", "crimson", "pink", "violet", "yellow"]
xpositions = [0,55,105,145,200,225]
ypositions = [0,25,-10,25,50,10]

i = 0
while i < 6:
    blume(colors[i], xpositions[i], ypositions[i])
    i = i + 1
</code>

=== NA4 ===
<code python>
from gturtle import *
flori = Turtle()
flori.hideTurtle()
flori.clear("seagreen")

def blume(color, xpos, ypos):
    flori.setPenColor(color)
    flori.setPos(xpos, ypos)
    i = 0
    while i < 6:
        flori.rightArc(20, 60)
        flori.dot(30)
        i = i + 1

colors = ["orange", "purple", "pink", "crimson", "indigo", "violet", "magenta", "deeppink", "gold", "lightcoral"]

i = 0
while i < 20:
    col_pos = random.randint(0,9)
    blume(colors[col_pos], random.randint(-250,250), random.randint(-100,100))
    i = i + 1
</code>
++++
</nodisp>

<nodisp 1>
++++Lösungen zu Aufgaben NB:|
=== NB1 ===
<code python>
def chf_in_nok(chf):
    return chf * 12.57

print(chf_in_nok(3))
</code>

=== NB2 ===
<code python>
def max_von_zwei(a, b):
    if a > b:
        return a
    else:
        return b

print(max_von_zwei(2,3))
print(max_von_zwei(3,4))
</code>

=== NB3 ===
<code python>
def zutaten_pfannkuchen(n):
    return n * 50, n * 0.125, n, n

n = input("Wie viele Personen?")
mehl, salz, milch, ei = zutaten_pfannkuchen(n)
print(f"Du brauchst:\n{mehl} g Mehl\n{salz} TL Salz\n{milch} dl Milch\n{ei} Eier")
</code>

=== NB4 ===
<code python>
def min_von_drei(a, b, c):
    if a < b and a < c:
        return a
    elif b < a and b < c:
        return b
    else:
        return c

print(min_von_drei(1,2,3))
print(min_von_drei(5,6,4))
print(min_von_drei(9,7,8))
</code>

=== NB5 ===
<code python>
list1 = [11, 16, 5, 12, 3, 13] 
list2 = [13, 2, 5, 10, 1, 17, 5, 25]
list3 = [-25, -13, -3, -33]

def max_in_liste(liste):
    max_wert = liste[0]
    i = 1
    while i < len(liste):
        if liste[i] > max_wert:
            max_wert = liste[i]
        i = i + 1
    return max_wert

print(max_in_liste(list1))
print(max_in_liste(list2))
print(max_in_liste(list3))
</code>

=== NB6 ===
<code python>
def ist_gerade(n):
    if n % 2 == 0:
        return True
    return False

print(ist_gerade(4))
print(ist_gerade(5))
</code>

=== NB7 ===
<code python>
def pizza_lieferung(personen):
    if personen * 12 >= 50:
        return personen * 12
    else:
        return personen * 12 + 20

print(pizza_lieferung(4))
print(pizza_lieferung(5))
</code>

=== NB8 ===
<code python>

</code>
++++
</nodisp>

<nodisp 1>
++++Lösungen zu Aufgaben NC:|

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

def hexagon(): 
    side_count = 0
    while side_count < 6:
        karl.forward(50)
        karl.right(60)
        side_count = side_count + 1

hex_count = 0 
while hex_count < 6:
    hexagon()
    karl.forward(50)
    karl.left(60)
    hex_count = hex_count + 1
</code>
=== NC2 ===
<code python>
import random
from gturtle import * 
flori = Turtle()

def punkte(min, max, colors):
    i = 0
    anz = random.randint(min, max)
    while i < anz:
        xpos = random.randint(-250,250)
        ypos = random.randint(-100,100)
        flori.setPenColor(colors[random.randint(0,len(colors)-1)])
        flori.setPos(xpos, ypos)
        flori.dot(20)
        i = i + 1
    return i

farben = ["red", "blue", "green", "orange"]

anz_punkte = punkte(5, 40, farben)
print(f"Es wurden {anz_punkte} Punkte gezeichnet.")
</code>

=== NC3 ===
<code python>
import random
from gturtle import *
tommy = Turtle()
tommy.hideTurtle()
tommy.clear("goldenrod")

def herzblatt(seite, farbe):
    tommy.setFillColor(farbe)
    tommy.startPath()
    tommy.forward(seite)
    tommy.rightArc(seite/2,180)
    tommy.left(90)
    tommy.rightArc(seite/2,180)
    tommy.forward(seite)
    tommy.fillPath()
    tommy.right(90)

def kleeblatt3(radius):
    i = 0
    while i < 3:
        herzblatt(radius, "green")
        tommy.right(120)
        i = i + 1

def kleeblatt4(radius):
    i = 0
    while i < 4:
        herzblatt(radius, "darkgreen")
        tommy.right(90)
        i = i + 1
        
i = 1 
while i < 30:
    xpos = random.randint(-250,250)
    ypos = random.randint(-100, 100)
    size = random.randint(20,30)
    tommy.setPos(xpos, ypos)

    if i % 7 == 0: 
        kleeblatt4(size)
    elif i % 3 == 0:
        kleeblatt3(size)
    else:
        tommy.setPenColor("crimson")
        tommy.dot(size)
        
    i = i + 1
</code>

=== NC3 Zusatzaufgabe===
<code python>
import random
import math
from gturtle import *
tommy = Turtle()
tommy.hideTurtle()
tommy.clear("lightpink")

def herzblatt2(seite, farbe1, farbe2):
    tommy.setFillColor(farbe1)
    tommy.startPath()
    tommy.forward(seite)
    tommy.rightArc(seite/2,180)
    tommy.right(45)
    tommy.forward(seite*math.sqrt(2))
    tommy.fillPath()
    tommy.setFillColor(farbe2)
    tommy.startPath()
    tommy.left(135)
    tommy.forward(seite)
    tommy.leftArc(seite/2,180)
    tommy.left(45)
    tommy.forward(seite*math.sqrt(2))
    tommy.fillPath()
    
def kleeblatt3(radius):
    i = 0
    while i < 3:
        herzblatt2(radius, "forestgreen", "green")
        tommy.right(15)
        i = i + 1  

def kleeblatt4(radius):
    i = 0
    while i < 4:
        herzblatt2(radius, "darkgreen", "007200")
        tommy.right(45)
        i = i + 1

i = 1 
while i < 30:
    xpos = random.randint(-250,250)
    ypos = random.randint(-100, 100)
    size = random.randint(20,30)
    tommy.setPos(xpos, ypos)

    if i % 7 == 0: 
        kleeblatt4(size)
    elif i % 3 == 0:
        kleeblatt3(size)
    else:
        tommy.setPenColor("crimson")
        tommy.dot(size)
        
    i = i + 1
</code>

=== NC4 ===
<WRAP group>
<WRAP column half>
Variante mit While-Schleife:

<code python>
def text_reverse(text):
    new_text = ""
    i = len(text)-1
    while i >= 0:
        new_text = new_text + text[i]
        i = i-1
    return new_text
        
print(text_reverse("Roti Rösli im Garte"))
</code>
</WRAP>
<WRAP column half>
Kurze Variante mit Slice-Syntax (optional):

<code python>
def text_reverse(text):
    return text[::-1]
        
print(text_reverse("Roti Rösli im Garte"))
</code>
</WRAP>
</WRAP>


=== NC5 ===
<code python>
def replace_spaces(text, char):
    i = 0
    new_text = ""
    while i < len(text):
        if text[i] == ' ':
            new_text = new_text + char
        else:
            new_text = new_text + text[i]
        i = i + 1
    return new_text

print(replace_spaces("Roti Rösli im Garte", '-'))
</code>

=== NC6 ===
<code python>
def word_list(text):
    words = []
    word = ""
    i = 0
    while i < len(text):
        if text[i] == ' ': # Leerzeichen
            words.append(word)
            word = ""
        else:
            word = word + text[i]
        i = i + 1
    words.append(word)
    return words

def words_reverse(text): 
    words = word_list(text)
    new_text = ""
    i = len(words) - 1
    while i >= 0:
        new_text = new_text + words[i] + " "
        i = i - 1
    return new_text

print(words_reverse("Roti Rösli im Garte"))
</code>
++++
</nodisp>

<nodisp 1>
++++Lösungen zu Aufgaben O:|

=== O1 ===
<code python>
def hotel_preise2(personen, naechte, anreisetag):
    doppelzimmer = personen // 2
    einzelzimmer = personen % 2
    tage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]    
    starttag = tage.index(anreisetag)
    preis = 0
    nacht = 0
    
    while nacht < naechte:
        aktueller_tag_index = (starttag + nacht) % 7
        aktueller_tag = tage[aktueller_tag_index]
        
        if aktueller_tag in ["Freitag", "Samstag"]:
            preis = preis + doppelzimmer * 200 + einzelzimmer * 150
        else:
            preis = preis + doppelzimmer * 140 + einzelzimmer * 120
            
        nacht = nacht + 1
        
    return preis

# Reise 1: 2 Personen, 2 Nächte ab Freitag: Preis = 400
print(hotel_preise2(2, 2, "Freitag"))
# Reise 2: 3 Personen, 4 Nächte ab Mittwoch: Preis = 1220 
print(hotel_preise2(3, 4, "Mittwoch"))
# Reise 3: 1 Person, 10 Nächte ab Donnerstag: Preis = 1320
print(hotel_preise2(1, 10, "Donnerstag"))
</code>

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

def rgb_dot(red, green, blue):
    hexcodes = ["00", "33", "66", "99", "CC", "FF"]
    colorcode = hexcodes[red] + hexcodes[green] + hexcodes[blue]
    paula.setPenColor(colorcode)
    paula.dot(40)
    
paula.right(90)
xpos = 0
ypos = 0

for r in range(6):

    for g in range(6):
    
        for b in range(6):
            paula.setPos(xpos, ypos)
            rgb_dot(r,g,b)
            xpos = xpos + 50
            
        xpos = xpos - 300
        ypos = ypos - 50
        
    xpos = xpos + 350
    ypos = 0
</code>

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

def fibonacci(n):
    fibs = []
    s1 = 0
    s2 = 1
    i = 0
    while i < n:
        fibs.append(s1)
        s = s1 + s2
        s1 = s2
        s2 = s
        i = i + 1
    return fibs

def viertelkreis(radius, farbe):
    leonardo.setFillColor(farbe)
    leonardo.startPath()
    leonardo.rightArc(radius, 90)
    leonardo.right(90)
    leonardo.forward(radius)
    leonardo.fillPath()
    leonardo.right(180)
    leonardo.forward(radius)
    leonardo.right(90)

def fibo_spirale(n):
    fibos = fibonacci(n)
    i = 0
    while i < len(fibos):
        radius = fibos[i] * 10
        if i % 2 == 0:
            viertelkreis(radius,"red")
        else:
            viertelkreis(radius,"blue")
        i = i + 1

def fibo_spirale2(n, colors):
    fibos = fibonacci(n)
    i = 0
    while i < len(fibos):
        radius = fibos[i] * 10
        viertelkreis(radius, colors[i % len(colors)])
        i = i + 1

leonardo.right(90)        
farben = ["crimson", "orange", "maroon", "gold"]
fibo_spirale2(9, farben)
</code>

=== O4 ===
<code python>
import math
from gturtle import * 

carl = Turtle()
carl.hideTurtle()

def segment(length, color):
    l1 = length * 0.8
    l2 = (length - l1)/2
    side = l2 * math.sqrt(2)
    carl.setFillColor(color)
    carl.startPath()
    carl.right(45)
    repeat 2:
        carl.forward(side)
        carl.left(45)
        carl.forward(l1)
        carl.left(45)
        carl.forward(side)
        carl.left(90)
    carl.fillPath()
    carl.left(45)

def seven_seg(number):
    segment_codes = ['1111110', # 0
                     '0110000', 
                     '1101101', 
                     '1111001', 
                     '0110011', 
                     '1011011', 
                     '1011111', 
                     '1110000', 
                     '1111111', 
                     '1111011'] # 9

    xpositions = [0, 100, 100, 100, 0, 0, 0]
    ypositions = [0, 0, -100, -200, -200, -100, -100]
    headings = [90, 180, 180, 270, 0, 0, 90]
    
    i = 0
    for s in segment_codes[number]:
        carl.setPos(xpositions[i], ypositions[i])
        carl.setHeading(headings[i])
        if s == '0':
            segment(100, "gainsboro")
        else:
            segment(100, "red")
        i = i + 1

i = 0
while i <= 9:
    seven_seg(i)
    i = i + 1
    delay(1000)
</code>
++++
</nodisp>