gf_informatik:funktionen:aufgaben

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

Wenn du das geschafft hast, darfst du folgendes Video schauen: Hexagons are the Bestagons.

NC2 – Random Dots

Schreibe eine Funktion punkte(min, max, farben) gemäss folgenden Anforderungen:
1. Die Argumente min und max geben an, wie viele Punkte mindestens und höchstens gezeichnet werden.
2. Das Argument farben ist eine Liste mit Farbnamen.
3. Die Funktion zeichnet eine zufällige Anzahl Punkte (20 px) im gewünschten Bereich.
4. Für jedem Punkt wird eine zufällige Farbe aus der Farbliste gewählt.
5. 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.
6. Die Funktion gibt zurück, wie viele Punkte sie gezeichnet hat.
Schreibe ein Programm, das die Funktion punkte verwendet:
1. Erstelle eine Liste mit vier bis sieben Farben.
2. 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

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:

Befehle mit Listen:

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

Befehle mit Strings:

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

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

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 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 dieses Liedes von Tommy James and the Shondells.

Schritt 1 – Herzblatt

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.

Schritt 2 – Kleeblätter

Schreibe eine weitere Funktionen kleeblatt3(radius), die ein grünes, 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 dunkelgrünes, vierblättriges Kleeblatt malt.

Schritt 3 – Crimson & Clover

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.

Zusatzaufgabe (Optional)

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:

import math
print(math.sqrt(4))

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

Lösungen zu Aufgaben NC:

NC1

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

NC2

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.")

NC3

Variante mit While-Schleife:

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"))

Kurze Variante mit Slice-Syntax (optional):

def text_reverse(text):
    return text[::-1]
 
print(text_reverse("Roti Rösli im Garte"))

NC4

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", '-'))

NC5

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

NC5 Zusatzaufgabe

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

NC6

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"))