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

=== NC4 – 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.

=== NC5 – Crimson & Clover  (Optional) ===
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>

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

==== Lösungen ====

<nodisp 2>
++++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 ===
<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>


=== NC4 ===
<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>

=== NC5 ===
<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>

=== NC5 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>

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