Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige Überarbeitung Vorherige Überarbeitung
Nächste Überarbeitung		 Vorherige Überarbeitung
gf_informatik:programmieren_iv_gra [2025-06-26 19:14] – [Programmieren Teil 4 – Funktionen (Unterprogramme)] gragf_informatik:programmieren_iv_gra [2026-05-13 08:56] (aktuell) – [4. Lösungen zu den Aufträgen] gra
Zeile 1: Zeile 1:
-====== Programmieren Teil 4 – Funktionen (Unterprogramme) ====== +====== Programmieren Teil 4 – Funktionen ====== 
-  * Dieses Seite ist die Fortsetzung von [[gf_informatik:programmieren_iii_gra|]]. +  * Dieses Seite ist die Fortsetzung von [[gf_informatik:programmieren_iii_gra|]]. 
 +  * Weiter zu [[gf_informatik:programmieren_v_gra|]].
  
-<nodisp 2> 
-++++Verbessern (hidden):| 
-  * Fancy Aufgaben nach O verschieben, dafür mehr einfache, kleine Aufgaben zum Üben.  
-    * Insbesondere mehr Aufgaben mit Listen und 
-    * Verknüpfungen von Bedingungen mit logischen Operatoren 
-  * Evtl. Lernziele bezüglich Verknüpfungen von Bedingungen präzisieren.  
-++++ 
-</nodisp> 
  
 ++++Lernziele:| ++++Lernziele:|
Zeile 197: Zeile 190:
 ===== - Aufgaben N – Funktionen ===== ===== - Aufgaben N – Funktionen =====
 In folgenden Aufgaben sollst du Funktionen erstellen (= definieren) und verwenden (=aufrufen). In folgenden Aufgaben sollst du Funktionen erstellen (= definieren) und verwenden (=aufrufen).
 +  * [[.:funktionen:aufgaben_a|]]
 +  * [[.:funktionen:aufgaben_b|]]
 +  * [[.:funktionen:aufgaben_c|]]
 +  * [[.:funktionen:aufgaben_d|]]
  
-==== Aufgaben NA – Einfache Funktionen (Unterprogramme) ohne Rückgabewerte ==== 
-Die folgenden Aufgaben behandeln Funktionen mit und ohne Argumente – aber ohne Rückgabewerte. 
  
-=== NA1 – Blumen === +===== - Lösungen zu den Aufträgen =====
-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> <nodisp 1>
Zeile 781: Zeile 291:
 </nodisp> </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> 
  • gf_informatik/programmieren_iv_gra.1750965298.txt.gz
  • Zuletzt geändert: 2025-06-26 19:14
  • von gra