Die vorliegenden Materialien wurden von Daniel Hoherz erstellt. Sollten andere Editoren die Materialien erstellt haben, werden diese explizit genannt. Die Abbildungen wurden mit der KI FLUX.1 von Black Forest Labs oder Nano Banana Pro von Google erstellt.
Algorithmen in Scratch
In dieser Einheit vertiefen Sie die Arbeit mit Listen in Scratch und entwickeln neue Algorithmen, mit denen sich ganze Reihen von Messdaten analysieren lassen. Im anschließenden zweiten Teil der Einheit werden diese Programme in die textbasierte Programmiersprache Java übertragen.
Zwei Niveaustufen: Fast alle Aufgaben werden in einer schwierigen Variante und einer Standardvariante angeboten. Die Standardvariante ist das, was von Ihnen erwartet wird. Sie ist kleinschrittiger und bietet mehr Anhaltspunkte. Die schwierigen Varianten sind teilweise wirklich herausfordernd und setzen stärker auf eigenständiges Entdecken und Entwickeln. Inhaltlich unterscheiden sich beide Varianten nie – Sie können also jederzeit das Niveau wechseln. Die schwierige Variante steht immer zuerst, damit niemand beim Scrollen ungewollt Hinweise bekommt.
Programmiert wird mit Scratch 3 direkt im Browser: Scratch-Editor öffnen (externe Seite, neuer Tab)
Algorithmische Grundlagen aus den Jahrgängen 9 und 10 optional
Zunächst werden Ihre Kenntnisse zu Algorithmen aus den vergangenen Schuljahren aufgefrischt.
Hinweis: Einige Inhalte dieses Abschnitts kommen im Abschnitt „Messdaten aufnehmen und auswerten in Scratch“ noch einmal vor: die Schleife mit Indexvariable in Aufgabe 1 b) und die Vorteile von Schleifen in Aufgabe 2. Wenn Sie diesen Abschnitt bearbeitet haben, können Sie diese Stellen später zügig erledigen.
Die Auswilderung von 14 Wölfen im Yellowstone-Nationalpark im Jahr 1995 ist eines der berühmtesten Fallbeispiele der modernen Ökologie und zeigt eindrucksvoll, welche Macht in der Auswertung von Langzeitdaten steckt. Zuvor war der Wolf dort über 70 Jahre lang ausgerottet gewesen. In dieser Zeit wuchs die Population der Wapiti-Hirsche unkontrolliert an, was zu einer massiven Überweidung der Flusstäler führte. Junge Weiden und Pappeln hatten keine Chance zu wachsen.
Als Biologen begannen, nach der Rückkehr der Wölfe systematisch Datenreihen zu erheben und diese übereinanderzulegen, offenbarte sich eine sogenannte trophische Kaskade (eine ökologische Kettenreaktion). Die Messdaten zeigten nicht nur, wie die Wolfspopulation anstieg und die Hirschpopulation im Gegenzug sank (ein klassisches Räuber-Beute-Modell), sondern auch, wie sich die Vegetation explosionsartig erholte. Die Auswertung dieser Daten führte zunächst zu der populären Theorie der „Ökologie der Angst“: Die Hirsche mieden aus Furcht vor den Wölfen die ungeschützten Flusstäler, wodurch die Bäume an den Ufern zurückkehren konnten.
Moderne, noch feiner granulierte Datenauswertungen zeigen heute jedoch ein komplexeres Bild: Die Erholung des Ökosystems war nicht allein das Werk der Wölfe, sondern ein Zusammenspiel aus veränderten Wasserständen, dem Jagdverhalten von Bären und Pumas sowie klimatischen Faktoren. Genau das macht dieses Szenario für die Datenanalyse so faszinierend: Erst durch das kontinuierliche Sammeln und statistische Modellieren verschiedenster Variablen, von Tierzählungen über Baumhöhen bis hin zu hydrologischen Messwerten, lässt sich die wahre Komplexität eines solchen Netzwerks entschlüsseln.
Aufgaben
Aufgabe 1: Variablen (Austauschphase → gesamte Lerngruppe)
Ein besonders anschaulicher Indikator für die Erholung der Flusstäler war die Rückkehr der Biber. Biber sind zwingend auf Weiden- und Pappelholz als Nahrungsquelle und Baumaterial angewiesen. Vor der Rückkehr der Wölfe gab es im nördlichen Teil des Parks kaum noch Biber. Mit dem Nachwachsen der Bäume veränderten die neuen Biberdämme schließlich sogar die Flussläufe und schufen neue Feuchtgebiete.
Zu fünf Zeitpunkten wurden Messungen aufgenommen:
Jahr der Messung
1996
2001
2006
2011
2017
Anzahl erfasster Biberkolonien (Dämme)
wert1
wert2
wert3
wert4
wert5
Ein erstes Programm zum Speichern der Messdaten ist unten abgebildet.
Wenn Taste [a v] gedrückt wird
frage [Gib Wert 1 ein.] und warte
setze [wert1 v] auf (Antwort)
frage [Gib Wert 2 ein.] und warte
setze [wert2 v] auf (Antwort)
frage [Gib Wert 3 ein.] und warte
setze [wert3 v] auf (Antwort)
frage [Gib Wert 4 ein.] und warte
setze [wert4 v] auf (Antwort)
frage [Gib Wert 5 ein.] und warte
setze [wert5 v] auf (Antwort)
sage (verbinde [Wert 1 ist: ] und (wert1)) für (1) Sekunden
sage (verbinde [Wert 2 ist: ] und (wert2)) für (1) Sekunden
sage (verbinde [Wert 3 ist: ] und (wert3)) für (1) Sekunden
sage (verbinde [Wert 4 ist: ] und (wert4)) für (1) Sekunden
sage (verbinde [Wert 5 ist: ] und (wert5)) für (1) Sekunden
Programm zum Speichern der Messdaten
Ihr Bearbeitungsfortschritt:0%
Analysieren Sie das abgebildete Programm: Was geschieht nach dem Drücken der Taste „a“ Schritt für Schritt?
Erläutern Sie, weshalb für die Umsetzung dieses Programms Variablen zwingend notwendig sind.
Begründen Sie, weshalb die Variable wert5 nicht unbedingt notwendig ist.
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 1.
a) Das Programm fragt nacheinander fünf Werte ab und speichert jede Antwort sofort in einer eigenen Variablen (wert1 bis wert5). Anschließend gibt es die fünf Werte nacheinander jeweils eine Sekunde lang aus.
b) Ein Computer benötigt ein „Gedächtnis“: Jede neue Eingabe überschreibt den Inhalt von Antwort. Damit am Ende alle fünf Werte ausgegeben werden können, muss jeder Wert in einer Variablen gespeichert werden, bevor die nächste Frage gestellt wird.
c) Die Variable wert5 ist nicht unbedingt notwendig: Nach der fünften Frage wird keine weitere Frage gestellt. Der fünfte Wert steht deshalb bis zum Ende in Antwort und könnte direkt von dort ausgegeben werden.
Aufgabe 2: Entscheidungen (Austauschphase → gesamte Lerngruppe)
Um zu überprüfen, ob die Anzahl der Biberkolonien von 1996 auf 2001 gestiegen ist, werden die beiden folgenden Vorschläge gemacht, die an das Programm aus Aufgabe 1 angehängt werden sollen.
falls <(wert2) > (wert1)> , dann
sage [Die Anzahl ist gestiegen.] für (2) Sekunden
end
falls <<(wert2) < (wert1)> oder <(wert2) = (wert1)>> , dann
sage [Die Anzahl ist nicht gestiegen.] für (2) Sekunden
end
Vorschlag 1
falls <(wert2) > (wert1)> , dann
sage [Die Anzahl ist gestiegen.] für (2) Sekunden
sonst
sage [Die Anzahl ist nicht gestiegen.] für (2) Sekunden
end
Vorschlag 2
Ihr Bearbeitungsfortschritt:0%
Begründen Sie, weshalb ein Computer bei den Vergleichsblöcken (grün) und den „sage“-Blöcken (lila) „arbeiten“ muss und weshalb es sinnvoll ist, diese Arbeit möglichst gering zu halten.
Erläutern Sie möglichst genau, wie ein Computer bei der Ausführung der beiden Vorschläge jeweils vorgeht. Unterscheiden Sie hierbei die zwei Fälle:
wert2 ist größer als wert1
wert2 ist kleiner als wert1 oder gleich groß
So wird „Arbeit“ gezählt: Jede ausgeführte Anweisung (z. B. sage, setze, ändere) und jeder ausgeführte Vergleich (z. B. >, <, =) zählt als ein Arbeitsschritt. Die Verknüpfungen und, oder und nicht werden nicht extra gezählt.
Untersuchen Sie, wie häufig ein Computer bei den zwei Fällen in beiden Vorschlägen „arbeiten“ muss.
Vergleichen Sie die beiden Vorschläge hinsichtlich ihrer Effizienz.
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 2.
a) Ein Computer „arbeitet“ bei jeder Anweisung und bei jedem Vergleich. Jeder Arbeitsschritt kostet Zeit und Energie. Bei großen Datenmengen oder häufig ausgeführten Programmen macht sich das deutlich bemerkbar.
b) Bei Vorschlag 1 prüft der Computer zuerst, ob wert2 > wert1 gilt, und gibt in diesem Fall „Die Anzahl ist gestiegen.“ aus. Danach prüft er in jedem Fall auch die zweite Bedingung (wert2 < wert1 oder wert2 = wert1) und gibt gegebenenfalls „Die Anzahl ist nicht gestiegen.“ aus. Bei Vorschlag 2 prüft der Computer nur eine Bedingung. Ist sie wahr, führt er den „dann“-Teil aus, sonst den „sonst“-Teil.
c)
Fall
Vorschlag 1 (zwei bedingte Anweisungen)
Vorschlag 2 (Verzweigung)
wert2 > wert1
3 Vergleiche, 1 Ausgabe
1 Vergleich, 1 Ausgabe
wert2 ≤ wert1
3 Vergleiche, 1 Ausgabe
1 Vergleich, 1 Ausgabe
d) Vorschlag 1 prüft in jedem Fall beide Bedingungen, obwohl nach der ersten Prüfung schon feststeht, welche Ausgabe richtig ist. Die Verzweigung in Vorschlag 2 ist deshalb effizienter.
Aufgabe 3: Schleifen (Austauschphase → gesamte Lerngruppe)
Um die Ausgabe von Messdaten testen zu können, wurden verschiedene Entwürfe angefertigt.
Wenn Taste [b v] gedrückt wird
wiederhole fortlaufend
frage [Wie viele Zahlen sollen generiert werden?] und warte
setze [anzahl v] auf (Antwort)
wiederhole (anzahl) mal
sage (Zufallszahl von (1) bis (10)) für (1) Sekunden
end
end
Entwurf 1
Wenn Taste [c v] gedrückt wird
wiederhole fortlaufend
frage [Wie viele Zahlen sollen generiert werden?] und warte
setze [anzahl v] auf (Antwort)
setze [index v] auf (1)
wiederhole bis <(index) > (anzahl)>
sage (Zufallszahl von (1) bis (10)) für (1) Sekunden
ändere [index v] um (1)
end
end
Entwurf 2
Ihr Bearbeitungsfortschritt:0%
Beschreiben Sie den Ablauf der beiden Programme.
Erläutern Sie, welchen Zweck die Endlosschleife „wiederhole fortlaufend“ erfüllt.
Die beiden Entwürfe unterscheiden sich nur in den beiden folgenden Teilen des Programms:
wiederhole (anzahl) mal
sage (Zufallszahl von (1) bis (10)) für (1) Sekunden
end
Entwurf 1
setze [index v] auf (1)
wiederhole bis <(index) > (anzahl)>
sage (Zufallszahl von (1) bis (10)) für (1) Sekunden
ändere [index v] um (1)
end
Entwurf 2
Angenommen, die nutzende Person hat für die Anzahl der Zahlen eine 3 eingegeben.
Geben Sie an, wie oft die Anweisung in der „wiederhole x mal“-Schleife (Zählschleife) von Entwurf 1 ausgeführt wird.
Ermitteln Sie für Entwurf 2 bei der Eingabe 3 die Werte der Variablen index: beim ersten Start der „wiederhole bis“-Schleife (bedingte Schleife), nach dem ersten Schleifendurchlauf und am Ende. Wie oft werden die Anweisungen in der Schleife ausgeführt?
Zählen Sie nach den Regeln aus Aufgabe 2 c) exakt, wie viele Male ein Computer bei den beiden abgebildeten Programmteilen „arbeiten“ muss.
Diskutieren Sie, ob in der Zeile wiederhole x mal (dem Schleifenkopf) „Arbeit“ entsteht.
Beurteilen Sie, welcher Entwurf effizienter ist, also weniger „Arbeit“ für einen Computer bedeutet.
Angenommen, es sind drei Zufallszahlen auszugeben und es liegen hierfür zwei Entwürfe vor:
wiederhole (3) mal
sage (Zufallszahl von (1) bis (10)) für (1) Sekunden
end
Entwurf 1
sage (Zufallszahl von (1) bis (10)) für (1) Sekunden
sage (Zufallszahl von (1) bis (10)) für (1) Sekunden
sage (Zufallszahl von (1) bis (10)) für (1) Sekunden
Entwurf 2
Zählen Sie auch hier die Anzahl der Aktionen eines Computers.
Diskutieren Sie, inwiefern Schleifen Vorteile bei der Programmierung bringen, wenn nacheinander die folgenden Änderungen an den Anforderungen bei beiden Entwürfen vorgenommen werden sollen:
Die Anzahl der Zufallszahlen soll von 3 auf 100 erhöht werden.
Der Bereich der Zufallszahlen soll von 1 bis 10 zu −10 bis 10 verändert werden.
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 3.
a) Beide Programme starten mit einer Taste („b“ bzw. „c“) und fragen in einer Endlosschleife immer wieder, wie viele Zufallszahlen erzeugt werden sollen. Anschließend geben sie entsprechend viele Zufallszahlen zwischen 1 und 10 nacheinander aus. Entwurf 1 nutzt dafür eine Zählschleife, Entwurf 2 eine bedingte Schleife mit der Variablen index.
b) Die Endlosschleife sorgt dafür, dass das Programm nach einer Ausgabe nicht endet, sondern sofort erneut nach der Anzahl fragt. So kann man die Ausgabe beliebig oft testen, ohne das Programm neu zu starten.
c) Die Anweisung wird dreimal ausgeführt.
d) Beim ersten Start der Schleife hat index den Wert 1, nach dem ersten Durchlauf den Wert 2. Am Ende hat index den Wert 4: Nach dem dritten Durchlauf wird index auf 4 erhöht, die Bedingung 4 > 3 ist erfüllt und die Schleife endet. Die Anweisungen in der Schleife werden also dreimal ausgeführt.
e) Entwurf 2: 1 × setze, 4 Vergleiche im Schleifenkopf, 3 × sage und 3 × ändere, also 11 Arbeitsschritte. Bei Entwurf 1 sind nur die 3 × sage zu sehen.
f) Ja. Auch eine Zählschleife muss intern mitzählen, wie oft sie schon durchlaufen wurde, und vor jedem Durchlauf vergleichen, ob sie weiterläuft. Diese Arbeit ist nur nicht als eigener Block sichtbar.
g) Rechnet man die versteckte Arbeit im Schleifenkopf mit, sind beide Entwürfe etwa gleich effizient. Entwurf 1 wirkt nur effizienter, weil weniger Blöcke zu sehen sind.
h) Ohne Schleife sind es genau 3 Arbeitsschritte (3 × sage). Mit Schleife kommt die versteckte Arbeit im Schleifenkopf hinzu. Hier ist das Programm ohne Schleife also sogar etwas effizienter.
i) Mit Schleife muss bei beiden Änderungen nur eine Stelle angepasst werden: Die 3 wird zu 100, bzw. der Bereich wird in einem einzigen Block geändert. Ohne Schleife müssten 97 Blöcke ergänzt bzw. alle 100 Blöcke einzeln geändert werden.
Wichtige Erkenntnisse:
Schleifen machen ein Programm nicht automatisch schneller: Auch der Schleifenkopf verursacht „Arbeit“ für einen Computer.
Die Funktionsweise von Schleifen, insbesondere einer bedingten Schleife mit Indexvariable.
Auch Zählschleifen verursachen im Schleifenkopf versteckte „Arbeit“ für einen Computer (mitzählen und vergleichen), genau wie eine bedingte Schleife mit Indexvariable. Beide Schleifenarten sind gleich mächtig und lassen sich ineinander umwandeln.
Ein Mehrwert von Schleifen liegt z. B. in Anwendungsbereichen mit variabler Datenmenge und/oder wenn Änderungen am Programm vorgenommen werden müssen.
Algorithmische Datenauswertung in Scratch – Umwelt-Monitoring-System
Bilder von einer KI erstellt
Dürre, Hochwasser, Smog, verschmutztes Wasser und Waldbrände: Viele Umweltprobleme lassen sich nur erkennen und bewerten, wenn über lange Zeit Messdaten gesammelt und ausgewertet werden.
EinstiegAustausch mit benachbarten Personen → gesamte Lerngruppe Beschreiben Sie die Umweltprobleme, die auf den Bildern A bis E dargestellt sind. Sammeln Sie, welche Messdaten man erheben müsste, um diese Probleme frühzeitig zu erkennen und ihre Entwicklung zu verfolgen.
Feinstaub und Smog Feinstaub entsteht vor allem durch Verkehr, Industrie und Heizungen. Messstationen erfassen die Feinstaubbelastung der Luft, damit bei hohen Werten gewarnt werden kann.
Wasserverschmutzung Industrieabfälle, Dünger und Plastik gelangen in Flüsse und Seen. Sensoren messen zum Beispiel die Wassertemperatur und den Sauerstoffgehalt des Wassers.
Dürre und Hitze Lange Trockenphasen und Hitzewellen nehmen zu. Temperatur- und Niederschlagsmessungen zeigen, wie sich das Klima vor Ort verändert, auch an Ihrer Schule.
In dieser Einheit arbeiten Sie mit Temperaturdaten: zunächst mit den Messwerten einer Wetterstation, danach mit den Temperaturen von zehn Schulen an einem heißen Sommertag. Dafür entwickeln Sie Algorithmen, die solche Messreihen speichern und auswerten.
Messdaten aufnehmen und auswerten in Scratch
Bild von einer KI erstellt
Aufgaben
Aufgabe 1
Angenommen, eine Messstation mit verschiedenen Sensoren nimmt jeden Tag zu bestimmten Zeiten Temperaturwerte auf und gibt diese weiter. Die Temperaturen werden immer zu den Zeiten 00 Uhr, 06 Uhr, 12 Uhr und 18 Uhr aufgenommen und sollen gespeichert werden. Die Temperaturdaten sollen jederzeit gezielt eingesehen und auch ausgewertet werden können. Hierfür liegen die beiden folgenden Vorschläge vor.
Vorschlag 1
Vorschlag 2
temperatur114
temperatur212
temperatur327
temperatur435
temperatur513
temperatur613
temperatur726
temperatur826
temperatur914
temperatur1010
temperatur1129
temperatur1233
temperatur1313
temperatur1413
temperatur1528
temperatur1628
temperatur1714
temperatur1810
temperatur1930
temperatur2033
temperatur2113
temperatur2213
temperatur2334
temperatur2432
temperaturen00
114
213
314
413
514
613
+ Länge: 6 =
temperaturen06
112
213
310
413
510
613
+ Länge: 6 =
temperaturen12
127
226
329
428
530
634
+ Länge: 6 =
temperaturen18
135
226
333
428
533
632
+ Länge: 6 =
Für jede Temperatur wird eine Variable angelegt, in der die jeweilige Temperatur gespeichert wird.
Für jeden Messzeitpunkt wird eine Liste angelegt. Es gibt also eine Liste für jeden der vier Messzeitpunkte.
Für eine spätere Analyse dieser Daten möchte man z. B. wissen, wie die Durchschnittstemperatur um 12 Uhr oder die Maximaltemperatur um 00 Uhr jeweils seit Beginn der Aufzeichnungen gewesen ist.
Ihr Bearbeitungsfortschritt:0%
Diskutieren und entscheiden Sie, welche Variante Sie besser finden.
Zunächst wiederholen Sie grundlegende Funktionsweisen und das Arbeiten mit Listen in Scratch sowie Algorithmen mit grundlegenden Kontrollstrukturen. Über den folgenden Link erreichen Sie Scratch: Scratch-Editor öffnen (externe Seite, neuer Tab)
Variablen
Neue Variable
(my variable)
setze [my variable v] auf (0)
ändere [my variable v] um (1)
Neue Liste
Meine Blöcke
Neuer Block
Liste im Variablenbereich anlegen
Neue Liste ×
Neuer Listenname:
temperaturen
◉ Für alle Figuren ○ Nur für diese Figur
AbbrechenOK
Liste benennen
(temperaturen)
füge [Ding] zu [temperaturen v] hinzu
lösche (1) aus [temperaturen v]
lösche alles aus [temperaturen v]
füge [Ding] bei (1) in [temperaturen v] ein
ersetze Element (1) von [temperaturen v] durch [Ding]
(Element (1) von [temperaturen v])
(Nummer von [Ding] in [temperaturen v])
(Länge von [temperaturen v])
<[temperaturen v] enthält [Ding]?>
zeige Liste [temperaturen v]
verstecke Liste [temperaturen v]
Listenblöcke im Bereich Variablen
Erstellen Sie eine Liste mit dem Namen temperaturen.
Implementieren Sie ein Programm, das mit dem Startblock „Wenn ⚑ angeklickt wird“ beginnt und die folgenden Anforderungen erfüllt. Nur zum Zurücksetzen der Liste legen Sie ein zweites, separates Skript an.
Nach dem Programmstart sollen mit dem Block (Zufallszahl von (10) bis (20)) drei zufällige Werte zwischen 10 und 20 an die Liste temperaturen angehängt werden.
Erstellen Sie dieses zweite Skript mit dem Ereignisstartblock „Wenn Taste r gedrückt wird“. Wenn dieser Programmteil ausgelöst wird, soll alles aus der Liste temperaturen gelöscht werden. Testen Sie, ob das Einfügen und Löschen funktioniert.
Nach dem Einfügen der drei zufälligen Werte soll mit mehreren Blöcken sage (Element (1) von [temperaturen v]) für (1) Sekunden der Inhalt Ihrer Liste temperaturen ausgegeben werden.
Anschließend soll der zweite Wert in der Liste temperaturen durch 21 ersetzt werden.
Danach soll geprüft werden, ob der dritte Wert der Liste temperaturen größer als 15 ist. Wenn das so ist, soll ausgegeben werden, dass der Wert größer als 15 ist. Wenn nicht, dass er kleiner oder gleich 15 ist. Hierfür können die folgenden Blöcke hilfreich sein (eine Übersicht zu bedingter Anweisung und Verzweigung finden Sie im Abschnitt „Bedingungen und Entscheidungen“):
falls <> , dann
end
falls <> , dann
end
– oder –
falls <> , dann
sonst
end
sage ( ) für ( ) Sekunden
(Element ( ) von [temperaturen v])
<( ) > ( )>
Verändern Sie Ihr Programm so, dass nicht drei zufällige Werte, sondern eine zufällige Anzahl zwischen 5 und 10 Werten in die Liste temperaturen eingefügt werden. Hierfür wird der Block wiederhole ( ) mal benötigt. Die Blöcke zur Ausgabe sollen zunächst entfernt werden.
Nach dem veränderten Einfügen soll geprüft werden, ob die Liste mehr als 4 Elemente enthält. Geben Sie das Ergebnis passend aus.
Erstellen Sie nun eine neue Variable (keine Liste) mit dem Namen index und setzen Sie direkt zu Beginn des Programms deren Startwert auf 1.
Ergänzen Sie Ihr Programm ganz unten mit dem folgenden Algorithmus:
wiederhole bis <(index) > (Länge von [temperaturen v])>
sage (Element (index) von [temperaturen v]) für (1) Sekunden
ändere [index v] um (1)
end
Probieren Sie das gesamte Programm aus und diskutieren Sie die folgenden Fragen:
Welchen Wert hat die Variable index, wenn die „wiederhole bis“-Schleife das erste Mal beginnt?
Wie verändert sich der Wert der Variablen index, wenn die Anweisungen in der Schleife einmal ausgeführt wurden?
Welches Element Ihrer Liste temperaturen wird beim ersten und beim zweiten Schleifendurchlauf ausgegeben?
Bis zu welchem Wert von index werden die Anweisungen in der Schleife weiter ausgeführt und welchen Wert hat index, wenn die Schleife „fertig“ durchgelaufen ist?
Weshalb ist die Anweisung „ändere index um 1“ notwendig und was würde passieren, wenn man diesen Block löschen würde?
Was würde passieren, wenn man in der Anweisung „ändere index um 1“ die 1 auf den Wert 2 ändern würde?
Was würde passieren, wenn man im Schleifenkopf die Anweisung „index > Länge von temperaturen“ zu „index > 5“ ändern würde?
Bietet die Variante für die Ausgabe der Listenelemente mit dieser Schleifenkonstruktion Vorteile im Vergleich zu der vorherigen Variante mit den Blöcken sage (Element (1) von [temperaturen v]) für (1) Sekunden?
Reflexion: Kernideen sichern Sichern Sie die Kernideen dieser Aufgabe für sich, zum Beispiel in Ihrem Heft:
Kernidee:Notieren Sie in eigenen Worten, wie eine Liste viele Messwerte unter einem Namen speichert und welche Aufgabe die Variable index beim Durchlaufen hat.
Stolperstein:Halten Sie fest, was passiert, wenn index in der Schleife nicht erhöht wird.
Selbsttest: Können Sie ohne Scratch angeben, welches Element beim dritten Schleifendurchlauf ausgegeben wird und welchen Wert index nach dem Ende der Schleife hat?
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 1.
a)
Die beiden genannten Analyseaufträge lassen sich in den beiden Varianten folgendermaßen lösen:
Durchschnittstemperatur um 12 Uhr
Einzelne Variablen
Listen
Man müsste wissen, welche Temperaturen wann aufgenommen wurden. Wenn man diese Regelmäßigkeit kennt, müsste man all diese Temperaturen finden und addieren. Außerdem muss die Anzahl der Werte mitgezählt werden, um anschließend die Summe durch diese Anzahl zu teilen.
Man kann direkt alle Werte der Liste temperaturen12 addieren und anschließend durch die Länge der Liste teilen.
Maximaltemperatur um 00 Uhr (Es ist nicht notwendig, die genaue Bestimmung des Maximums hier bereits zu kennen!)
Einzelne Variablen
Listen
Man müsste wissen, welche Temperaturen wann aufgenommen wurden. Wenn man diese Regelmäßigkeit kennt, müsste man all diese Temperaturen finden und miteinander vergleichen.
Man kann direkt alle Werte der Liste temperaturen00 miteinander vergleichen.
Listen eignen sich gut, um viele Daten zu speichern. Gründe:
Alle Daten stehen in einem einzigen Objekt. Man muss sich nicht viele Variablennamen merken.
Über den Index kann man direkt auf jedes Element zugreifen.
Daten lassen sich ohne großen Suchaufwand einfügen und ändern.
Ausgaben und Auswertungen der Daten lassen sich gut mit einer Schleife lösen.
Wichtig: Eine Liste braucht nicht weniger Speicher als viele einzelne Variablen. Ihre Vorteile liegen in der Struktur und darin, dass sie beliebig wachsen und schrumpfen kann.
In Aufgabe 1 ging es um die Messwerte einer Station über mehrere Tage. Jetzt geht es um einen einzelnen heißen Sommervormittag: Die Temperaturdaten von zehn verschiedenen Schulen sollen in einer Liste in Scratch gespeichert werden. Das könnte zum Beispiel folgendermaßen interpretiert werden:
Schule 1: GSG Osnabrück
Schule 2: Ratsgymnasium
Schule 3: EMA
…
Schule 10: Ursulaschule
temperaturen
125.0
227.5
328.0
431.0
533.5
633.1
732.0
833.0
931.0
1026.8
+ Länge: 10 =
🏆 Schwierige Variante
Ihr Bearbeitungsfortschritt (schwierige Variante):0%
Öffnen Sie den Scratch-Editor mit einem neuen, leeren Projekt: Scratch-Editor öffnen (externe Seite, neuer Tab). Speichern Sie das Projekt gleich zu Beginn unter dem Namen „Messwerte aufnehmen und ausgeben“.
Speichern ohne Scratch-Konto: Über „Datei“ → „Auf deinem Computer speichern“ laden Sie Ihr Projekt als .sb3-Datei herunter. Über „Datei“ → „Von deinem Computer hochladen“ öffnen Sie es später wieder. Speichern Sie nach jedem Aufgabenteil.
Erstellen Sie ein Programm, welches die folgenden Anforderungen erfüllt.
Das Programm soll starten, wenn die Taste „s“ gedrückt wurde.
Eine Liste temperaturen soll deklariert und nach dem Start des Programms komplett geleert werden.
Die folgenden zehn Temperaturwerte sollen in die Liste eingetragen werden:
25.0, 27.5, 28.0, 31.0, 33.5, 33.1, 32.0, 33.0, 31.0 und 26.8. (Achtung: Geben Sie 31.0 und nicht 31,0 ein!)
Die Messstation soll die gespeicherten Daten auch versenden können. Das Versenden wird zunächst mit dem „sage _ für _ Sekunden“-Block nachgestellt.
Erweitern Sie Ihr Programm so, dass alle gespeicherten Temperaturdaten der Reihenfolge nach in den beiden folgenden Varianten ausgegeben werden:
Die gespeicherten Temperaturen sollen einzeln aus der Liste ausgelesen und mit jeweils einem „sage _ für _ Sekunden“-Block ausgegeben werden.
Die gespeicherten Temperaturen sollen mit einer „wiederhole bis _“-Schleife ausgegeben werden.
Untersuchen Sie in Scratch, welche Änderungen in beiden Varianten notwendig sind, wenn die folgenden Anforderungen umgesetzt werden sollen.
Die Temperaturen sollen in umgekehrter Reihenfolge ausgegeben werden, beginnend mit der letzten Temperatur.
Es soll, beginnend mit der ersten Temperatur, nur jede zweite Temperatur ausgegeben werden.
Beurteilen Sie, inwiefern eine Umsetzung mit einer Schleife hier Vorteile bietet.
Eine Wissenschaftlerin möchte sich aussuchen können, von welcher Schule sie sich die Temperatur anzeigen lässt. Dafür soll sie die Taste „t“ drücken können. Anschließend wird sie nach einem Index gefragt, gibt diesen ein und die Messstation gibt die Temperatur der gewünschten Schule aus.
Erweitern Sie Ihr Programm um diese Funktionalität. Nutzen Sie hierfür einen weiteren Startblock, dessen Programmteil nur beim Drücken der Taste „t“ ausgelöst wird.
Speichern Sie Ihr Programm unter dem Namen „Temperaturwerte“ ab.
Erweitern Sie Ihr Programm so, dass es das folgende Problem abfängt: Was ist, wenn ein Index eingegeben wird, den es nicht gibt?
✅ Standardvariante
Ihr Bearbeitungsfortschritt (Standardvariante):0%
Öffnen Sie den Scratch-Editor mit einem neuen, leeren Projekt: Scratch-Editor öffnen (externe Seite, neuer Tab). Speichern Sie das Projekt gleich zu Beginn unter dem Namen „Messwerte aufnehmen und ausgeben“.
Speichern ohne Scratch-Konto: Über „Datei“ → „Auf deinem Computer speichern“ laden Sie Ihr Projekt als .sb3-Datei herunter. Über „Datei“ → „Von deinem Computer hochladen“ öffnen Sie es später wieder. Speichern Sie nach jedem Aufgabenteil.
Erstellen Sie ein Programm, welches die folgenden Anforderungen erfüllt.
Das Programm soll starten, wenn die Taste „s“ gedrückt wurde.
Eine Liste temperaturen soll deklariert und nach dem Start des Programms komplett geleert werden.
Die folgenden zehn Temperaturwerte sollen in die Liste eingetragen werden:
25.0, 27.5, 28.0, 31.0, 33.5, 33.1, 32.0, 33.0, 31.0 und 26.8. (Achtung: Geben Sie 31.0 und nicht 31,0 ein!)
Die Messstation soll die gespeicherten Daten auch versenden können. Das Versenden wird zunächst mit dem „sage _ für _ Sekunden“-Block nachgestellt:
sage (Element (1) von [temperaturen v]) für (1) Sekunden
Erweitern Sie Ihr Programm so, dass alle gespeicherten Temperaturdaten der Reihenfolge nach ausgegeben werden.
Für die Ausgabe der Messdaten, nachdem sie gespeichert wurden, sind unten zwei Varianten dargestellt:
sage (Element (1) von [temperaturen v]) für (1) Sekunden
sage (Element (2) von [temperaturen v]) für (1) Sekunden
sage (Element (3) von [temperaturen v]) für (1) Sekunden
sage (Element (4) von [temperaturen v]) für (1) Sekunden
sage (Element (5) von [temperaturen v]) für (1) Sekunden
sage (Element (6) von [temperaturen v]) für (1) Sekunden
sage (Element (7) von [temperaturen v]) für (1) Sekunden
sage (Element (8) von [temperaturen v]) für (1) Sekunden
sage (Element (9) von [temperaturen v]) für (1) Sekunden
sage (Element (10) von [temperaturen v]) für (1) Sekunden
Variante 1
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
sage (Element (index) von [temperaturen v]) für (1) Sekunden
ändere [index v] um (1)
end
Variante 2
Beschreiben Sie die Funktionsweise der beiden Varianten.
Untersuchen Sie in Scratch, welche Änderungen in beiden Varianten notwendig sind, wenn die folgenden Anforderungen umgesetzt werden sollen. Für Variante 2 müssen Sie in Scratch eine neue Variable (keine Liste) mit dem Namen index deklarieren.
Die Temperaturen sollen in umgekehrter Reihenfolge ausgegeben werden, beginnend mit der letzten Temperatur.
Es soll, beginnend mit der ersten Temperatur, nur jede zweite Temperatur ausgegeben werden.
Beurteilen Sie, inwiefern eine Umsetzung mit einer Schleife hier Vorteile bietet.
Eine Wissenschaftlerin möchte sich aussuchen können, von welcher Schule sie sich die Temperatur anzeigen lässt. Dafür soll sie die Taste „t“ drücken können. Anschließend wird sie nach einem Index gefragt, gibt diesen ein und die Messstation gibt die Temperatur der gewünschten Schule aus.
Erweitern Sie Ihr Programm um diese Funktionalität. Nutzen Sie hierfür einen weiteren Startblock, dessen Programmteil nur beim Drücken der Taste „t“ ausgelöst wird.
Speichern Sie Ihr Programm unter dem Namen „Temperaturwerte“ ab.
Erweitern Sie Ihr Programm so, dass es das folgende Problem abfängt: Was ist, wenn ein Index eingegeben wird, den es nicht gibt?
Reflexion: Kernideen sichern Sichern Sie die Kernideen dieser Aufgabe für sich, zum Beispiel in Ihrem Heft:
Kernidee:Skizzieren Sie das Muster „Liste durchlaufen“ mit seinen drei Bausteinen: Startwert von index, Abbruchbedingung und Erhöhung.
Stolperstein:Notieren Sie, weshalb im Schleifenkopf Länge von temperaturen besser ist als eine feste Zahl.
Selbsttest: Können Sie einer anderen Person in zwei Sätzen erklären, welche Vorteile die Schleife gegenüber zehn einzelnen Anweisungen hat?
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 2.
In dieser Aufgabe haben Sie die Arbeit mit Listen und „wiederhole bis“-Schleifen mit einer Indexvariablen wiederholt.
a) bis c) (Standard) / a) und b) (schwierig)
Wenn Taste [s v] gedrückt wird
lösche alles aus [temperaturen v]
füge (25.0) zu [temperaturen v] hinzu
füge (27.5) zu [temperaturen v] hinzu
füge (28.0) zu [temperaturen v] hinzu
füge (31.0) zu [temperaturen v] hinzu
füge (33.5) zu [temperaturen v] hinzu
füge (33.1) zu [temperaturen v] hinzu
füge (32.0) zu [temperaturen v] hinzu
füge (33.0) zu [temperaturen v] hinzu
füge (31.0) zu [temperaturen v] hinzu
füge (26.8) zu [temperaturen v] hinzu
sage (Element (1) von [temperaturen v]) für (1) Sekunden
sage (Element (2) von [temperaturen v]) für (1) Sekunden
sage (Element (3) von [temperaturen v]) für (1) Sekunden
sage (Element (4) von [temperaturen v]) für (1) Sekunden
sage (Element (5) von [temperaturen v]) für (1) Sekunden
sage (Element (6) von [temperaturen v]) für (1) Sekunden
sage (Element (7) von [temperaturen v]) für (1) Sekunden
sage (Element (8) von [temperaturen v]) für (1) Sekunden
sage (Element (9) von [temperaturen v]) für (1) Sekunden
sage (Element (10) von [temperaturen v]) für (1) Sekunden
c) (schwierig)
Ergänzung zum bisherigen Programm:
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
sage (Element (index) von [temperaturen v]) für (1) Sekunden
ändere [index v] um (1)
end
d) (Standard)
Variante 1 gibt nacheinander alle Temperaturen mit zehn Einzelanweisungen aus. Variante 2 nutzt eine „wiederhole bis“-Schleife mit einer Indexvariablen. Damit wird in jedem Schleifendurchlauf die Temperatur am Index index ausgegeben. Anschließend wird index um 1 erhöht.
d) (schwierig) / e) (Standard)
Folgende Vorteile der Schleife lassen sich festhalten:
Ohne Schleife müssen alle „sage“-Blöcke getauscht werden.
Mit der Schleife müssen nur Startwert, Schrittweite und gegebenenfalls die Abbruchbedingung angepasst werden. Rückwärts: setze index auf Länge von temperaturen, ändere index um -1 und wiederhole bis index < 1. Jede zweite Temperatur: ändere index um 2, die Abbruchbedingung bleibt gleich.
e) (schwierig) / f) (Standard)
Wenn Taste [t v] gedrückt wird
frage [Für welche Schule möchten Sie die Temperatur wissen?] und warte
sage (Element (Antwort) von [temperaturen v]) für (2) Sekunden
Ohne Zusatz
Wenn Taste [t v] gedrückt wird
frage [Für welche Schule möchten Sie die Temperatur wissen?] und warte
falls <<(Antwort) > (Länge von [temperaturen v])> oder <(Antwort) < (1)>> , dann
sage [Diese Schule gibt es nicht.] für (2) Sekunden
sonst
sage (Element (Antwort) von [temperaturen v]) für (2) Sekunden
end
Mit Zusatz
Aufgabe 3
Unsere Wissenschaftlerin möchte nun die vorliegenden Messdaten analysieren. Hierfür möchte sie zunächst die Durchschnittstemperatur der zehn Temperaturen ermitteln.
🏆 Schwierige Variante
Ihr Bearbeitungsfortschritt (schwierige Variante):0%
Diskutieren Sie, wie Sie hierbei vorgehen können.
Deklarieren Sie zwei neue Variablen mit den Namen summe und durchschnitt und initialisieren Sie beide Variablen nach dem Programmstart mit dem Wert 0. Entfernen Sie die Ausgabe der zehn Temperaturdaten aus Ihrem bisherigen Programm.
Erweitern Sie Ihr Programm so, dass zunächst die Summe der zehn Temperaturen berechnet wird, und lassen Sie sich danach den Wert der Summe in einem vollständigen Satz ausgeben.
Erweitern Sie es anschließend so, dass nach der Berechnung der Summe auch der Durchschnitt berechnet wird. Lassen Sie sich auch diesen in einem vollständigen Satz ausgeben.
Zur Selbstkontrolle: Mit den zehn Temperaturen aus Aufgabe 2 ergeben sich die Summe 300.9 und der Durchschnitt 30.09. Scratch zeigt dabei eventuell 300.90000000000003 bzw. 30.090000000000003 an. Das ist kein Fehler in Ihrem Programm: Der Computer speichert Dezimalzahlen im Binärsystem, und viele Dezimalzahlen lassen sich dort nicht exakt darstellen. Dadurch entstehen winzige Rundungsfehler.
Speichern Sie Ihr Programm ab.
Eine andere Gruppe hat zur Berechnung des Durchschnitts den folgenden Algorithmus entwickelt. Er liefert allerdings kein richtiges Ergebnis.
setze [summe v] auf (0)
setze [index v] auf (0)
wiederhole bis <(index) < (Länge von [temperaturen v])>
ändere [summe v] um (Element (index) von [temperaturen v])
end
setze [durchschnitt v] auf ((summe) / (Länge von [temperaturen v]))
Fehlerhafter Algorithmus
In einer Tracetabelle notiert man nach jedem Schleifendurchlauf die aktuellen Werte der Variablen. So lässt sich Schritt für Schritt nachvollziehen, was ein Algorithmus tatsächlich tut.
c1)Erstellen Sie für den Algorithmus eine Tracetabelle mit den zehn Temperaturen aus Ihrer Liste. Tragen Sie am Ende jedes Schleifendurchlaufs eine Zeile ein und am Ende des Programms eine Endzeile (Spalte „Schleifendurchlauf“: –). Die Spalte durchschnitt füllen Sie nur in der Endzeile aus. Erklären Sie, weshalb Ihre Tabelle keine Zeile für einen Schleifendurchlauf enthält.
Schleifendurchlauf
index
summe
durchschnitt
c2)Korrigieren Sie zunächst nur die Abbruchbedingung zu index > Länge von temperaturen. Führen Sie die Tracetabelle für die ersten drei Schleifendurchläufe fort und beschreiben Sie, was Sie beobachten.
Schleifendurchlauf
index
summe
durchschnitt
c3)Korrigieren Sie alle weiteren Fehler. Überprüfen Sie Ihre Korrektur mit einer Tracetabelle für die ersten zwei Schleifendurchläufe und die Endzeile.
Schleifendurchlauf
index
summe
durchschnitt
✅ Standardvariante
Ihr Bearbeitungsfortschritt (Standardvariante):0%
Diskutieren Sie, wie Sie hierbei vorgehen können.
Deklarieren Sie zwei neue Variablen mit den Namen summe und durchschnitt und initialisieren Sie beide Variablen nach dem Programmstart mit dem Wert 0. Entfernen Sie die Ausgabe der zehn Temperaturdaten aus Ihrem bisherigen Programm.
Erweitern Sie Ihr Programm so, dass zunächst die Summe der zehn Temperaturen berechnet wird, und lassen Sie sich danach den Wert der Summe in einem vollständigen Satz ausgeben.
Hierfür können Sie auch die folgenden Blöcke nutzen:
ändere [summe v] um ( )
wiederhole bis <>
end
setze [index v] auf ( )
(Element ( ) von [temperaturen v])
(Länge von [temperaturen v])
(summe)
ändere [index v] um ( )
<( ) > ( )>
(index)
Erweitern Sie es anschließend so, dass nach der Berechnung der Summe auch der Durchschnitt berechnet wird. Lassen Sie sich auch diesen in einem vollständigen Satz ausgeben.
Zur Selbstkontrolle: Mit den zehn Temperaturen aus Aufgabe 2 ergeben sich die Summe 300.9 und der Durchschnitt 30.09. Scratch zeigt dabei eventuell 300.90000000000003 bzw. 30.090000000000003 an. Das ist kein Fehler in Ihrem Programm: Der Computer speichert Dezimalzahlen im Binärsystem, und viele Dezimalzahlen lassen sich dort nicht exakt darstellen. Dadurch entstehen winzige Rundungsfehler.
Speichern Sie Ihr Programm ab.
Eine andere Gruppe hat zur Berechnung des Durchschnitts den folgenden Algorithmus entwickelt. Er liefert allerdings kein richtiges Ergebnis.
setze [summe v] auf (0)
setze [index v] auf (0)
wiederhole bis <(index) < (Länge von [temperaturen v])>
ändere [summe v] um (Element (index) von [temperaturen v])
end
setze [durchschnitt v] auf ((summe) / (Länge von [temperaturen v]))
Fehlerhafter Algorithmus
In einer Tracetabelle notiert man nach jedem Schleifendurchlauf die aktuellen Werte der Variablen. So lässt sich Schritt für Schritt nachvollziehen, was ein Algorithmus tatsächlich tut.
c1)Erstellen Sie für den Algorithmus eine Tracetabelle mit den zehn Temperaturen aus Ihrer Liste. Tragen Sie am Ende jedes Schleifendurchlaufs eine Zeile ein und am Ende des Programms eine Endzeile (Spalte „Schleifendurchlauf“: –). Die Spalte durchschnitt füllen Sie nur in der Endzeile aus. Erklären Sie, weshalb Ihre Tabelle keine Zeile für einen Schleifendurchlauf enthält.
Schleifendurchlauf
index
summe
durchschnitt
c2)Korrigieren Sie zunächst nur die Abbruchbedingung zu index > Länge von temperaturen. Führen Sie die Tracetabelle für die ersten drei Schleifendurchläufe fort und beschreiben Sie, was Sie beobachten.
Schleifendurchlauf
index
summe
durchschnitt
c3)Korrigieren Sie alle weiteren Fehler. Überprüfen Sie Ihre Korrektur mit einer Tracetabelle für die ersten zwei Schleifendurchläufe und die Endzeile.
Schleifendurchlauf
index
summe
durchschnitt
Tipp zu c1)
Setzen Sie die Startwerte in die Bedingung im Schleifenkopf ein. Ist die Bedingung schon vor dem ersten Durchlauf wahr? Was bedeutet das bei „wiederhole bis“?
Tipp zu c2) und c3)
Welchen Index hat das erste Element einer Scratch-Liste? Und was passiert mit index während eines Schleifendurchlaufs?
Reflexion: Kernideen sichern Sichern Sie die Kernideen dieser Aufgabe für sich, zum Beispiel in Ihrem Heft:
Kernidee:Halten Sie das Muster „Summe und Durchschnitt“ als Scratch-Skript oder als Struktogramm (siehe Zusammenfassung) fest.
Stolperstein:Legen Sie eine kurze Fehler-Checkliste für Schleifen an: Startwert, Abbruchbedingung, Erhöhung. Damit können Sie künftig jede Schleife prüfen.
Selbsttest: Wann lohnt sich eine Tracetabelle, und was zeigt sie, was man dem Programm nicht direkt ansieht?
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 3.
a)
Siehe Vorgehensweise in b).
b)
setze [summe v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
ändere [summe v] um (Element (index) von [temperaturen v])
ändere [index v] um (1)
end
setze [durchschnitt v] auf ((summe) / (Länge von [temperaturen v]))
c1)
Schleifendurchlauf
index
summe
durchschnitt
–
0
0
0
Die Tabelle enthält keine Zeile für einen Schleifendurchlauf: Schon vor dem ersten Durchlauf ist die Bedingung 0 < 10 wahr, die Schleife wird also kein einziges Mal ausgeführt. Am Ende sind summe und durchschnitt 0.
c2)
Schleifendurchlauf
index
summe
durchschnitt
1
0
0
2
0
0
3
0
0
Jetzt startet die Schleife, sie endet aber nie: index wird nicht erhöht und bleibt 0. Ein Element mit dem Index 0 gibt es in Scratch nicht, Element 0 ist leer und wird beim Addieren wie 0 behandelt. Deshalb bleibt auch summe bei 0. Es entsteht eine Endlosschleife.
c3) Der Algorithmus enthält drei Fehler:
Abbruchbedingung: Die Schleife soll enden, wenn index größer als die Länge der Liste ist. Richtig ist index > Länge von temperaturen.
Startwert: Das erste Element einer Scratch-Liste hat den Index 1. Die Variable index muss deshalb mit 1 starten. Beim Testen fällt dieser Fehler kaum auf: Element 0 ist in Scratch leer und wird beim Addieren wie 0 behandelt. Die Schleife läuft dann aber einmal zu oft.
Fehlende Erhöhung: Der Block ändere index um 1 fehlt. Korrigiert man nur die Abbruchbedingung, bleibt index immer gleich und es entsteht eine Endlosschleife.
Der korrigierte Algorithmus entspricht der Lösung von b). Tracetabelle zur Überprüfung:
Schleifendurchlauf
index
summe
durchschnitt
1
2
25
0
2
3
52.5
0
–
11
300.9
30.09
Bedingungen und Entscheidungen
Angenommen, eine Reihe von Temperatursensoren misst die Temperaturen an verschiedenen Schulen im Hochsommer. Die Temperaturwerte des Programms „Temperaturwerte“ sollen dies darstellen.
Natürlich hoffen die Schülerinnen und Schüler, dass es einen Hitzefrei-Tag gibt, wenn es sehr warm ist. Dafür müssen jedoch bestimmte Bedingungen erfüllt sein. Wenn diese Bedingungen erfüllt sind, gibt es Hitzefrei.
Dieses Konzept kennen Sie bereits aus Open Roberta und Scratch 3. Es gibt zwei Arten von Entscheidungen: eine bedingte Anweisung und eine Verzweigung.
Bedingte Anweisung
falls <> , dann
end
Bedingung: das Sechseck hinter „falls“
Wird ausgeführt, wenn die Bedingung „wahr“ ist: die Blöcke in der Klammer
Verzweigung
falls <> , dann
sonst
end
Bedingung: das Sechseck hinter „falls“
Wird ausgeführt, wenn die Bedingung „wahr“ ist: die Blöcke in der oberen Klammer
Wird ausgeführt, wenn die Bedingung „falsch“ ist: die Blöcke in der Klammer unter „sonst“
Aufgaben
Aufgabe 4 (Austausch mit benachbarten Personen → gesamte Lerngruppe)
Bei Scratch 3 sind alle sechseckigen Blöcke Bedingungen. Das sind Blöcke, deren „Antwort“ nur „wahr“ oder „falsch“ sein kann. Unten sehen Sie eine Auswahl solcher Blöcke.
<( ) > ( )>
<( ) < ( )>
<( ) = ( )>
Vergleichsoperatoren
<<> und <>>
<<> oder <>>
<nicht <>>
Logische Operatoren
<Taste (Leertaste v) gedrückt?>
Tastenblock
<[Apfel] enthält [pfe]?>
Zeichenkettenblock
<[temperaturen v] enthält (23.5)?>
Listenblock
Ihr Bearbeitungsfortschritt:0%
Tauschen Sie sich darüber aus, wie die einzelnen Blöcke funktionieren und in welchen Fällen „wahr“ oder „falsch“ geantwortet wird.
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 4.
Um zu prüfen, ob es Hitzefrei gibt, benötigt man bedingte Anweisungen („falls … dann“) oder Verzweigungen („falls … dann … sonst“). Die Bedingungsblöcke funktionieren so:
Vergleichsoperatoren: Diese Blöcke vergleichen zwei Werte (Zahlen oder Texte) miteinander und antworten z. B. „wahr“, wenn beim „…>…“-Block die linke Zahl größer als die rechte ist. Ist die rechte Zahl größer oder sind beide Zahlen gleich groß, antwortet er „falsch“. Die Blöcke „…<…“ und „…=…“ funktionieren entsprechend.
Logische Operatoren:
Der „und“-Block prüft, ob zwei Bedingungen gleichzeitig „wahr“ sind. In diesem Fall antwortet er „wahr“, sonst „falsch“.
Der „oder“-Block prüft, ob mindestens eine von zwei Bedingungen „wahr“ ist. Er antwortet „wahr“, wenn beide oder genau eine der beiden Bedingungen „wahr“ ist. Sind beide „falsch“, antwortet er „falsch“.
Der „nicht“-Block dreht die Antwort einer Bedingung um. Ist die Bedingung „wahr“, antwortet er „falsch“. Ist die Bedingung „falsch“, antwortet er „wahr“.
Tastenblock: Der Tastenblock antwortet „wahr“, wenn die entsprechende Taste gedrückt wird. Ansonsten „falsch“.
Zeichenkettenblock: Der Zeichenkettenblock antwortet „wahr“, wenn im linken Text der rechte Text enthalten ist. Im Beispiel würde der Block „wahr“ antworten, da im Wort „Apfel“ die Zeichenfolge „pfe“ enthalten ist.
Listenblock: Der Listenblock antwortet „wahr“, wenn das rechte Element in der links ausgewählten Liste enthalten ist. Im Beispiel würde er „wahr“ antworten, wenn 23.5 in der Liste temperaturen enthalten ist.
Aufgabe 5 (Partnerarbeit)
Als Grundlage für diese Aufgabe dient das Programm „Temperaturwerte“. Um eine automatisierte Statistik über hitzebedingte Unterrichtsausfälle aufzustellen, werten Sie die vorliegenden Temperaturdaten aus.
🏆 Schwierige Variante
Ihr Bearbeitungsfortschritt (schwierige Variante):0%
Angenommen, die Leitung einer Schule muss den Unterricht ausfallen lassen, sobald eine Temperatur von über 33 °C gemessen wird. Allerdings gilt dies nur, wenn es sich um einen Schultag, also nicht Samstag oder Sonntag, handelt. Dafür soll von einem Programm zunächst abgefragt werden, ob es sich um einen Schultag handelt. Hier wird „wahr“ oder „falsch“ eingegeben.
Anschließend wird gefragt, für welche Schule die Temperatur geprüft werden soll. Die nutzende Person soll hier eine Zahl zwischen 1 und 10 eingeben, welche sich auf die jeweilige Schule bezieht. Beide Antworten sollen im späteren Verlauf des Programms genutzt werden können.
Begründen Sie, weshalb für diese Situation mindestens eine Variable notwendig ist.
Geben Sie außerdem an, welche Art von Wert (Zahl, Text oder Wahrheitswert) die beiden Antworten jeweils darstellen.
Im Anschluss an die beiden Fragen soll geprüft werden, ob die Bedingungen für einen hitzebedingten Unterrichtsausfall erfüllt sind. In beiden Fällen soll eine passende Meldung ausgegeben werden.
Erweitern Sie Ihr Programm entsprechend und speichern Sie es ab.
Unten sind verschiedene Varianten für die Überprüfung von Aufgabenteil b) dargestellt. Vor den abgebildeten Varianten läuft jeweils der bekannte Programmanfang: Nach Drücken der Taste „s“ werden die zehn Temperaturen in die Liste temperaturen eingefügt.
Untersuchen Sie, ob die Varianten das Problem lösen, und erläutern Sie bei nicht funktionierenden Varianten die Fehler. Vergleichen Sie die beiden Programmausschnitte A und B und beurteilen Sie, ob einer der beiden Ausschnitte besser ist oder keiner einen entscheidenden Vorteil bietet.
Kriterium für den Vergleich: Zählen Sie für die vier möglichen Fälle (Temperatur über 33 °C ja/nein, Schultag ja/nein), wie viele Vergleiche jeweils ausgeführt werden. Es gilt die Zählregel aus den Grundlagen (Aufgabe 2 c): Jeder ausgeführte Vergleich (z. B. >, <, =) zählt als ein Schritt. Die Verknüpfungen und, oder und nicht werden nicht extra gezählt. Beziehen Sie außerdem die Lesbarkeit ein.
Varianten zur Prüfung auf Hitzefrei anzeigen
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
setze [hitzefrei v] auf [falsch]
falls <(Element (schule) von [temperaturen v]) > (33.0)> , dann
falls <(tag) = [wahr]> , dann
setze [hitzefrei v] auf [wahr]
end
end
falls <(hitzefrei) = [wahr]> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Variante 1
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
falls <(Element (schule) von [temperaturen v]) > (33.0)> , dann
falls <(tag) = [wahr]> , dann
sage [Hitzefrei!] für (2) Sekunden
end
end
sage [Kein Hitzefrei!] für (2) Sekunden
Variante 2
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
falls <<(Element (schule) von [temperaturen v]) > (33.0)> und <(tag) = [wahr]>> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Variante 3
Vergleich zweier Programmausschnitte:
setze [hitzefrei v] auf [falsch]
falls <(Element (schule) von [temperaturen v]) > (33.0)> , dann
falls <(tag) = [wahr]> , dann
setze [hitzefrei v] auf [wahr]
end
end
falls <(hitzefrei) = [wahr]> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Programmausschnitt A
falls <<(Element (schule) von [temperaturen v]) > (33.0)> und <(tag) = [wahr]>> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Programmausschnitt B
✅ Standardvariante
Ihr Bearbeitungsfortschritt (Standardvariante):0%
Angenommen, die Leitung einer Schule muss den Unterricht ausfallen lassen, sobald eine Temperatur von über 33 °C gemessen wird. Allerdings gilt dies nur, wenn es sich um einen Schultag, also nicht Samstag oder Sonntag, handelt. Dafür soll von einem Programm zunächst abgefragt werden, ob es sich um einen Schultag handelt. Hier wird „wahr“ oder „falsch“ eingegeben.
Anschließend wird gefragt, für welche Schule die Temperatur geprüft werden soll. Die nutzende Person soll hier eine Zahl zwischen 1 und 10 eingeben, welche sich auf die jeweilige Schule bezieht. Beide Antworten sollen im späteren Verlauf des Programms genutzt werden können.
Begründen Sie, weshalb für diese Situation mindestens eine Variable notwendig ist.
Geben Sie außerdem an, welche Art von Wert (Zahl, Text oder Wahrheitswert) die beiden Antworten jeweils darstellen.
Im Anschluss an die beiden Fragen soll geprüft werden, ob die Bedingungen für einen hitzebedingten Unterrichtsausfall erfüllt sind. In beiden Fällen soll eine passende Meldung ausgegeben werden.
Erweitern Sie Ihr Programm entsprechend und speichern Sie es ab.
Hinweise: Sie können hier auf verschiedene Arten vorgehen. Man kann z. B.
zwei bedingte Anweisungen ineinander geschachtelt nutzen,
mit einer Verzweigung arbeiten,
mit einer bedingten Anweisung und einem „und“-Block arbeiten.
Unten sind verschiedene Varianten für die Überprüfung von Aufgabenteil b) dargestellt. Vor den abgebildeten Varianten läuft jeweils der bekannte Programmanfang: Nach Drücken der Taste „s“ werden die zehn Temperaturen in die Liste temperaturen eingefügt.
Untersuchen Sie, ob die Varianten das Problem lösen, und erläutern Sie bei nicht funktionierenden Varianten die Fehler. Vergleichen Sie die beiden Programmausschnitte A und B und beurteilen Sie, ob einer der beiden Ausschnitte besser ist oder keiner einen entscheidenden Vorteil bietet.
Kriterium für den Vergleich: Zählen Sie für die vier möglichen Fälle (Temperatur über 33 °C ja/nein, Schultag ja/nein), wie viele Vergleiche jeweils ausgeführt werden. Es gilt die Zählregel aus den Grundlagen (Aufgabe 2 c): Jeder ausgeführte Vergleich (z. B. >, <, =) zählt als ein Schritt. Die Verknüpfungen und, oder und nicht werden nicht extra gezählt. Beziehen Sie außerdem die Lesbarkeit ein.
Varianten zur Prüfung auf Hitzefrei anzeigen
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
setze [hitzefrei v] auf [falsch]
falls <(Element (schule) von [temperaturen v]) > (33.0)> , dann
falls <(tag) = [wahr]> , dann
setze [hitzefrei v] auf [wahr]
end
end
falls <(hitzefrei) = [wahr]> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Variante 1
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
falls <(Element (schule) von [temperaturen v]) > (33.0)> , dann
falls <(tag) = [wahr]> , dann
sage [Hitzefrei!] für (2) Sekunden
end
end
sage [Kein Hitzefrei!] für (2) Sekunden
Variante 2
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
falls <<(Element (schule) von [temperaturen v]) > (33.0)> und <(tag) = [wahr]>> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Variante 3
Vergleich zweier Programmausschnitte:
setze [hitzefrei v] auf [falsch]
falls <(Element (schule) von [temperaturen v]) > (33.0)> , dann
falls <(tag) = [wahr]> , dann
setze [hitzefrei v] auf [wahr]
end
end
falls <(hitzefrei) = [wahr]> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Programmausschnitt A
falls <<(Element (schule) von [temperaturen v]) > (33.0)> und <(tag) = [wahr]>> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Programmausschnitt B
Reflexion: Kernideen sichern Sichern Sie die Kernideen dieser Aufgabe für sich, zum Beispiel in Ihrem Heft:
Kernidee:Notieren Sie, wann eine Verzweigung weniger Vergleiche benötigt als zwei bedingte Anweisungen.
Stolperstein:Halten Sie an einem eigenen Beispiel fest, was der „und“-Block leistet und wie er eine Schachtelung ersetzen kann.
Selbsttest: Können Sie für einen der vier Fälle aus Aufgabenteil c) die Anzahl der Vergleiche nach der Zählregel bestimmen?
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 5.
a)
Da zwei Antworten gespeichert werden müssen, ist mindestens eine Variable notwendig. Nachdem die zweite Antwort eingegeben wurde, wäre die erste Antwort verloren, würde diese nicht in einer Variablen gespeichert werden.
Die Schulnummer ist eine Zahl (Ganzzahl), die Angabe zum Schultag ein Wahrheitswert. Scratch speichert jede Antwort eines „frage“-Blocks allerdings als Text. Deshalb wird in der Lösung mit tag = wahr ein Text verglichen. In Java gibt es für solche Werte die Datentypen int und boolean.
b)
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
falls <<(Element (schule) von [temperaturen v]) > (33.0)> und <(tag) = [wahr]>> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
c)
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
setze [hitzefrei v] auf [falsch]
falls <(Element (schule) von [temperaturen v]) > (33.0)> , dann
falls <(tag) = [wahr]> , dann
setze [hitzefrei v] auf [wahr]
end
end
falls <(hitzefrei) = [wahr]> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Variante 1: Hier wird zunächst geprüft, ob die Bedingung an die Temperatur stimmt. Wenn ja, wird geprüft, ob es ein Schultag ist. In diesem Fall wird eine Variable hitzefrei auf „wahr“ gesetzt. Anschließend wird geprüft, ob hitzefrei „wahr“ ist. Entsprechend findet eine Ausgabe statt. → Diese Variante ist korrekt.
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
falls <(Element (schule) von [temperaturen v]) > (33.0)> , dann
falls <(tag) = [wahr]> , dann
sage [Hitzefrei!] für (2) Sekunden
end
end
sage [Kein Hitzefrei!] für (2) Sekunden
Variante 2: Hier wird zunächst geprüft, ob die Bedingung an die Temperatur stimmt. Wenn ja, wird geprüft, ob es ein Schultag ist. In diesem Fall wird ausgegeben, dass es Hitzefrei gibt. Anschließend wird ausgegeben, dass es kein Hitzefrei gibt. Dies passiert aber immer. → Diese Variante ist nicht korrekt.
frage [Ist heute ein Schultag?] und warte
setze [tag v] auf (Antwort)
frage [Welche Schule soll geprüft werden?] und warte
setze [schule v] auf (Antwort)
falls <<(Element (schule) von [temperaturen v]) > (33.0)> und <(tag) = [wahr]>> , dann
sage [Hitzefrei!] für (2) Sekunden
sonst
sage [Kein Hitzefrei!] für (2) Sekunden
end
Variante 3: Hier wird mit einem „und“-Operator geprüft, ob beide Bedingungen stimmen. Wenn ja, wird ausgegeben, dass es Hitzefrei gibt. Wenn nein, wird ausgegeben, dass es kein Hitzefrei gibt. → Diese Variante ist korrekt.
Programmausschnitt A entspricht dem Kern von Variante 1, Programmausschnitt B dem Kern von Variante 3.
Die Nutzung des „und“-Blocks ermöglicht es, die Schachtelung zu umgehen. Für den Effizienzvergleich werden die Vergleiche gezählt. Dabei ist zu beachten, dass Variante 1 am Ende immer noch den zusätzlichen Vergleich hitzefrei = wahr ausführt. Außerdem wertet Scratch beim „und“-Block immer beide Bedingungen aus, auch wenn die erste bereits „falsch“ ist. Erst in Java bricht && ab, sobald die erste Bedingung „falsch“ ist (Kurzschlussauswertung). Übersicht zur Anzahl der Vergleiche:
Fall
Variante 1
Variante 3 (Scratch)
Variante 3 in Java mit &&
Fall 1: Temperatur > 33 und tag = wahr
3 Vergleiche
2 Vergleiche
2 Vergleiche
Fall 2: Temperatur ≤ 33 und tag = wahr
2 Vergleiche
2 Vergleiche
1 Vergleich
Fall 3: Temperatur > 33 und tag = falsch
3 Vergleiche
2 Vergleiche
2 Vergleiche
Fall 4: Temperatur ≤ 33 und tag = falsch
2 Vergleiche
2 Vergleiche
1 Vergleich
Variante 3 ist in Scratch also in keinem Fall aufwendiger als Variante 1. In Java spart sie in jedem Fall genau einen Vergleich.
Aufgabe 6
Verschiedene Umwelt-Messdaten werden häufig detaillierter analysiert. Dafür müssen verschiedene Algorithmen entwickelt und implementiert werden. In dieser Aufgabe werden die vorliegenden Temperaturdaten detaillierter ausgewertet.
🏆 Schwierige Variante
Ihr Bearbeitungsfortschritt (schwierige Variante):0%
Für eine Statistik soll gezählt werden, an wie vielen Schulen an einem Tag hitzebedingt der Unterricht entfällt.
Diskutieren Sie, wie man hierbei vorgehen kann, wenn die Daten in Form einer Liste gespeichert sind. Gehen Sie auch darauf ein, ob und wofür weitere Variablen genutzt werden müssen.
Erweitern Sie Ihr Programm aus der vorherigen Aufgabe so, dass die Anzahl der Schulen mit hitzebedingtem Unterrichtsausfall gezählt und am Schluss mit einem vollständigen Satz ausgegeben wird.
Kontrollwert: Mit den zehn Temperaturen sind es 2 Schulen. Begründen Sie, weshalb die Schule mit genau 33.0 °C nicht mitgezählt wird.
Interessant ist auch die Frage, ob bestimmte Temperaturwerte ungewöhnlich hoch sind. Hierfür kann man z. B. den Durchschnitt einer Reihe von Temperaturen berechnen und anschließend prüfen, ob ein anderer Wert ungewöhnlich weit über dem Durchschnitt liegt.
Ein bemerkenswert hoher Temperaturwert ist einer, der mindestens 2 °C über dem Durchschnitt liegt. Es soll gezählt werden, wie viele der zehn Temperaturwerte mindestens 2 °C über dem Durchschnitt liegen, und eine entsprechende Ausgabe angezeigt werden.
Nutzen Sie dafür die Variable durchschnitt aus Aufgabe 3. Der Programmteil, der sie berechnet, muss vorher ausgeführt werden. Kontrollwert: 3 Werte.
Erweitern Sie Ihr Programm um diese Funktionalität.
Interessant ist auch die Frage, ob bestimmte Temperaturwerte ungewöhnlich sind. Hierfür kann man z. B. den Durchschnitt einer Reihe von Temperaturen berechnen und anschließend prüfen, ob ein anderer Wert ungewöhnlich weit vom Durchschnitt abweicht.
Ein besonders bemerkenswerter Temperaturwert ist einer, der um mindestens 2 °C vom Durchschnitt abweicht. Es soll gezählt werden, wie viele der zehn Temperaturwerte um mindestens 2 °C vom Durchschnitt abweichen, und eine entsprechende Ausgabe angezeigt werden.
Kontrollwert: 7 Werte.
Erweitern Sie Ihr Programm um diese Funktionalität.
Um Extremereignisse untersuchen zu können, sind häufig besonders hohe und besonders niedrige Werte spannend. Hierfür kann man zum Beispiel das Minimum und das Maximum der vorliegenden Daten bestimmen. Dazu werden zwei neue Variablen, max und min, benötigt.
Um z. B. ein Maximum zu bestimmen, setzt man den Wert von max auf das erste Element der Datenliste. Anschließend geht man die Liste schrittweise durch und vergleicht den aktuellen Wert von max mit dem aktuellen Listenelement. Wenn man einen größeren Wert gefunden hat, muss man das Maximum neu setzen.
Erweitern Sie Ihr Programm so, dass zusätzlich das Maximum und Minimum bestimmt und in vollständigen Sätzen ausgegeben werden.
Ergänzen Sie Ihr Programm so, dass in zwei weiteren Variablen minIndex und maxIndex gespeichert wird, an welcher Stelle der Liste das Minimum bzw. das Maximum steht.
Kontrollwerte: Maximum 33.5 an Index 5, Minimum 25 an Index 1.
Manchmal ist es sinnvoll, Daten sortiert anzuzeigen.
Erweitern Sie Ihr Programm so, dass das Maximum an die letzte Stelle der Liste gesetzt wird. Das Element, das bisher an der letzten Stelle stand, soll an die Stelle gesetzt werden, an der vorher das Maximum stand.
Hinweis: Bevor ein Element in der Liste überschrieben wird, muss sein Wert gesichert sein, zum Beispiel in einer Hilfsvariablen. Ansonsten ist er verloren.
Überlegen Sie sich eine Strategie, wie Sie nach und nach die komplette Liste aufsteigend sortieren können.
Erweitern Sie Ihr Programm so, dass die Werte in der Liste einmal aufsteigend und einmal absteigend sortiert werden können.
✅ Standardvariante
Ihr Bearbeitungsfortschritt (Standardvariante):0%
Für eine Statistik soll gezählt werden, an wie vielen Schulen an einem Tag hitzebedingt der Unterricht entfällt.
Diskutieren Sie, wie man hierbei vorgehen kann, wenn die Daten in Form einer Liste gespeichert sind. Gehen Sie auch darauf ein, weshalb eine weitere Variable anzahl, eine Schleife mit Variable index zum Durchlaufen der Liste, eine bedingte Anweisung und ein „>“-Block genutzt werden müssen.
Erweitern Sie Ihr Programm aus der vorherigen Aufgabe so, dass die Anzahl der Schulen mit hitzebedingtem Unterrichtsausfall gezählt und am Schluss mit einem vollständigen Satz ausgegeben wird.
Kontrollwert: Mit den zehn Temperaturen sind es 2 Schulen. Begründen Sie, weshalb die Schule mit genau 33.0 °C nicht mitgezählt wird.
Tipp 1: Vorgehen
Gehen Sie wie in a) besprochen vor: Ein Zähler anzahl startet vor der Schleife bei 0. Die Schleife durchläuft die Liste mit index. In jedem Durchlauf prüft eine bedingte Anweisung, ob die aktuelle Temperatur über 33 °C liegt. Nur dann wird anzahl um 1 erhöht.
Tipp 2: Hilfreiche Blöcke
ändere [anzahl v] um (1)
ändere [index v] um (1)
setze [anzahl v] auf (0)
setze [index v] auf (1)
(Element ( ) von [temperaturen v])
(Länge von [temperaturen v])
<( ) > ( )>
<( ) > (33)>
(anzahl)
(index)
(index)
wiederhole bis <>
end
falls <> , dann
end
(verbinde ( ) und [ Schulen haben einen hitzebedingten Unterrichtsausfall.])
sage ( ) für (2) Sekunden
Interessant ist auch die Frage, ob bestimmte Temperaturwerte ungewöhnlich hoch sind. Hierfür kann man z. B. den Durchschnitt einer Reihe von Temperaturen berechnen und anschließend prüfen, ob ein anderer Wert ungewöhnlich weit über dem Durchschnitt liegt.
Ein bemerkenswert hoher Temperaturwert ist einer, der mindestens 2 °C über dem Durchschnitt liegt. Es soll gezählt werden, wie viele der zehn Temperaturwerte mindestens 2 °C über dem Durchschnitt liegen, und eine entsprechende Ausgabe angezeigt werden.
Nutzen Sie dafür die Variable durchschnitt aus Aufgabe 3. Der Programmteil, der sie berechnet, muss vorher ausgeführt werden. Kontrollwert: 3 Werte.
Erweitern Sie Ihr Programm um diese Funktionalität.
Tipp 1: Vorgehen
„Mindestens 2 °C über dem Durchschnitt“ heißt: Element ≥ durchschnitt + 2. Scratch hat keinen ≥-Block. Überlegen Sie, wie Sie „≥“ aus zwei Vergleichen und einem „oder“-Block zusammensetzen können.
Tipp 2: Hilfreiche Blöcke
setze [anzahlZuHoch v] auf (0)
ändere [anzahlZuHoch v] um (1)
setze [index v] auf (1)
ändere [index v] um (1)
(Element ( ) von [temperaturen v])
(Element ( ) von [temperaturen v])
(Länge von [temperaturen v])
((durchschnitt) + (2))
(index)
wiederhole bis <>
end
falls <> , dann
end
sage ( ) für (2) Sekunden
<<> oder <>>
<( ) > ( )>
<( ) = ( )>
<( ) > ( )>
(index)
(index)
(anzahlZuHoch)
(verbinde ( ) und [ Werte sind mindestens 2°C über dem Durchschnitt])
Interessant ist auch die Frage, ob bestimmte Temperaturwerte ungewöhnlich sind. Hierfür kann man z. B. den Durchschnitt einer Reihe von Temperaturen berechnen und anschließend prüfen, ob ein anderer Wert ungewöhnlich weit vom Durchschnitt abweicht.
Ein besonders bemerkenswerter Temperaturwert ist einer, der um mindestens 2 °C vom Durchschnitt abweicht. Es soll gezählt werden, wie viele der zehn Temperaturwerte um mindestens 2 °C vom Durchschnitt abweichen, und eine entsprechende Ausgabe angezeigt werden.
Kontrollwert: 7 Werte.
Erweitern Sie Ihr Programm um diese Funktionalität.
Tipp 1: Vorgehen
„Abweichen“ heißt: nach oben oder nach unten. Sie brauchen also zwei Bedingungen: eine für Werte ≥ durchschnitt + 2 und eine für Werte ≤ durchschnitt − 2.
Tipp 2: Hilfreiche Blöcke
falls <> , dann
end
wiederhole bis <>
end
falls <> , dann
end
setze [index v] auf (1)
setze [anzahlAbweichend v] auf (0)
sage ( ) für (2) Sekunden
ändere [anzahlAbweichend v] um (1)
ändere [anzahlAbweichend v] um (1)
ändere [index v] um (1)
<<> oder <>>
<(Element (index) von [temperaturen v]) > ((durchschnitt) + (2))>
<(Element (index) von [temperaturen v]) = ((durchschnitt) - (2))>
<(Element (index) von [temperaturen v]) < ((durchschnitt) - (2))>
<(Element (index) von [temperaturen v]) = ((durchschnitt) + (2))>
(verbinde (anzahlAbweichend) und [ Werte weichen mindestens 2°C vom Durchschnitt ab])
<(index) > (Länge von [temperaturen v])>
<<> oder <>>
Um Extremereignisse untersuchen zu können, sind häufig besonders hohe und besonders niedrige Werte spannend. Hierfür kann man zum Beispiel das Minimum und das Maximum der vorliegenden Daten bestimmen. Dazu werden zwei neue Variablen, max und min, benötigt.
Um z. B. ein Maximum zu bestimmen, setzt man den Wert von max auf das erste Element der Datenliste. Anschließend geht man die Liste schrittweise durch und vergleicht den aktuellen Wert von max mit dem aktuellen Listenelement. Wenn man einen größeren Wert gefunden hat, muss man das Maximum neu setzen.
Erweitern Sie Ihr Programm so, dass zusätzlich das Maximum und Minimum bestimmt und in vollständigen Sätzen ausgegeben werden.
Ergänzen Sie Ihr Programm so, dass in zwei weiteren Variablen minIndex und maxIndex gespeichert wird, an welcher Stelle der Liste das Minimum bzw. das Maximum steht.
Kontrollwerte: Maximum 33.5 an Index 5, Minimum 25 an Index 1.
Tipp 1: Vorgehen
Setzen Sie max und min vor der Schleife auf das erste Element der Liste.
Durchlaufen Sie die Liste wie in den vorherigen Aufgabenteilen mit index.
Ist das aktuelle Element größer als max, wird max auf dieses Element gesetzt. Für min gehen Sie entsprechend mit „<“ vor.
Für maxIndex und minIndex speichern Sie im selben Moment zusätzlich den aktuellen Wert von index.
Tipp 2: Hilfreiche Blöcke für das Maximum
setze [max v] auf (Element (1) von [temperaturen v])
setze [maxIndex v] auf (1)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
end
falls <(Element (index) von [temperaturen v]) > (max)> , dann
end
setze [max v] auf (Element (index) von [temperaturen v])
setze [maxIndex v] auf (index)
ändere [index v] um (1)
sage (verbinde [Die höchste Temperatur ist: ] und (max)) für (2) Sekunden
Für das Minimum benötigen Sie die entsprechenden Blöcke mit min, minIndex und „<“.
Manchmal ist es sinnvoll, Daten sortiert anzuzeigen.
Erweitern Sie Ihr Programm so, dass das Maximum an die letzte Stelle der Liste gesetzt wird. Das Element, das bisher an der letzten Stelle stand, soll an die Stelle gesetzt werden, an der vorher das Maximum stand.
Hinweis: Bevor ein Element in der Liste überschrieben wird, muss sein Wert gesichert sein, zum Beispiel in einer Hilfsvariablen. Ansonsten ist er verloren.
Tipp 1: Vorgehen
Bestimmen Sie wie in e) das Maximum max und seinen Index maxIndex.
Speichern Sie das letzte Element der Liste in einer Hilfsvariablen hilf.
Ersetzen Sie das letzte Element durch max.
Ersetzen Sie das Element an der Stelle maxIndex durch hilf.
Tipp 2: Hilfreiche Blöcke für den Tausch
setze [hilf v] auf (Element (Länge von [temperaturen v]) von [temperaturen v])
ersetze Element (Länge von [temperaturen v]) von [temperaturen v] durch (max)
ersetze Element (maxIndex) von [temperaturen v] durch (hilf)
Überlegen Sie sich eine Strategie, wie Sie nach und nach die komplette Liste aufsteigend sortieren können.
Tipp 1: Frage
Wo steht das größte Element nach dem Tausch aus f)? Welcher Teil der Liste ist danach noch unsortiert?
Tipp 2: Strategie
Nach dem Tausch aus f) steht das größte Element bereits an der richtigen Stelle, nämlich ganz hinten. Was passiert, wenn Sie das Vorgehen aus f) noch einmal anwenden, das Maximum aber nur unter den Plätzen 1 bis Länge − 1 suchen und an den vorletzten Platz tauschen? Und danach unter den Plätzen 1 bis Länge − 2?
Erweitern Sie Ihr Programm so, dass die Werte in der Liste einmal aufsteigend und einmal absteigend sortiert werden können.
Tipp
Speichern Sie in einer Variablen listenlaenge, bis zu welchem Platz noch gesucht werden muss. Legen Sie eine zweite „wiederhole bis“-Schleife um Ihr Programm aus f) und verringern Sie listenlaenge nach jedem Tausch um 1. Für eine absteigende Sortierung suchen Sie statt des Maximums jeweils das Minimum.
Reflexion: Kernideen sichern Sichern Sie die Kernideen dieser Aufgabe für sich, zum Beispiel in Ihrem Heft:
Kernidee:Halten Sie die Muster „Zählen“, „Maximum suchen“ und „Tauschen“ jeweils als kurzes Skript oder Struktogramm fest.
Stolperstein:Notieren Sie, weshalb beim Tauschen ein Wert vorher gesichert werden muss.
Selbsttest: Können Sie in eigenen Worten beschreiben, wie das Sortieren durch Auswahl aus den Mustern „Maximum suchen“ und „Tauschen“ entsteht?
🎉 Ausgezeichnet – alle Aufgaben abgeschlossen!
Hier finden Sie Hinweise und mögliche Lösungen zu Aufgabe 6.
a)
Vorgehen:
Man geht die Liste mit den Temperaturen mit einer Schleife durch. Hierfür ist eine Variable, z. B. index, notwendig.
In jedem Durchlauf muss geprüft werden, ob die aktuelle Temperatur größer als 33 °C ist. Dafür ist eine bedingte Anweisung notwendig.
Wenn die Temperatur entsprechend hoch ist, muss eine weitere Variable erhöht werden, um die Anzahl der Schulen zu zählen.
b)
setze [anzahl v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
falls <(Element (index) von [temperaturen v]) > (33)> , dann
ändere [anzahl v] um (1)
end
ändere [index v] um (1)
end
sage (verbinde (anzahl) und [ Schulen haben einen hitzebedingten Unterrichtsausfall.]) für (2) Sekunden
c)
setze [anzahlZuHoch v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
falls <<(Element (index) von [temperaturen v]) > ((durchschnitt) + (2))> oder <(Element (index) von [temperaturen v]) = ((durchschnitt) + (2))>> , dann
ändere [anzahlZuHoch v] um (1)
end
ändere [index v] um (1)
end
sage (verbinde (anzahlZuHoch) und [ Werte sind mindestens 2°C über dem Durchschnitt]) für (2) Sekunden
d)
setze [anzahlAbweichend v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
falls <<(Element (index) von [temperaturen v]) > ((durchschnitt) + (2))> oder <(Element (index) von [temperaturen v]) = ((durchschnitt) + (2))>> , dann
ändere [anzahlAbweichend v] um (1)
end
falls <<(Element (index) von [temperaturen v]) < ((durchschnitt) - (2))> oder <(Element (index) von [temperaturen v]) = ((durchschnitt) - (2))>> , dann
ändere [anzahlAbweichend v] um (1)
end
ändere [index v] um (1)
end
sage (verbinde (anzahlAbweichend) und [ Werte weichen mindestens 2°C vom Durchschnitt ab]) für (2) Sekunden
e)
setze [min v] auf (Element (1) von [temperaturen v])
setze [max v] auf (Element (1) von [temperaturen v])
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
falls <(Element (index) von [temperaturen v]) > (max)> , dann
setze [max v] auf (Element (index) von [temperaturen v])
end
falls <(Element (index) von [temperaturen v]) < (min)> , dann
setze [min v] auf (Element (index) von [temperaturen v])
end
ändere [index v] um (1)
end
sage (verbinde [Die höchste Temperatur ist: ] und (max)) für (2) Sekunden
sage (verbinde [Die niedrigste Temperatur ist: ] und (min)) für (2) Sekunden
Ohne Indizes
setze [minIndex v] auf (1)
setze [maxIndex v] auf (1)
setze [min v] auf (Element (1) von [temperaturen v])
setze [max v] auf (Element (1) von [temperaturen v])
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
falls <(Element (index) von [temperaturen v]) > (max)> , dann
setze [max v] auf (Element (index) von [temperaturen v])
setze [maxIndex v] auf (index)
end
falls <(Element (index) von [temperaturen v]) < (min)> , dann
setze [min v] auf (Element (index) von [temperaturen v])
setze [minIndex v] auf (index)
end
ändere [index v] um (1)
end
sage (verbinde [Die höchste Temperatur ist: ] und (max)) für (2) Sekunden
sage (verbinde [Die niedrigste Temperatur ist: ] und (min)) für (2) Sekunden
Mit Indizes
f)
setze [maxIndex v] auf (1)
setze [max v] auf (Element (1) von [temperaturen v])
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
falls <(Element (index) von [temperaturen v]) > (max)> , dann
setze [maxIndex v] auf (index)
setze [max v] auf (Element (index) von [temperaturen v])
end
ändere [index v] um (1)
end
ersetze Element (maxIndex) von [temperaturen v] durch (Element (Länge von [temperaturen v]) von [temperaturen v])
ersetze Element (Länge von [temperaturen v]) von [temperaturen v] durch (max)
Eine eigene Hilfsvariable ist hier nicht nötig: max enthält bereits eine Kopie des Maximums. Deshalb darf das Element an der Stelle maxIndex zuerst überschrieben werden. Die Variante mit hilf aus dem Tipp ist ebenso richtig.
g)
Dieses Verfahren heißt Sortieren durch Auswahl (englisch: Selection Sort).
Wenn man wie in Aufgabenteil f) das Maximum gefunden und nach hinten getauscht hat, bestimmt man nun das Maximum der Listenplätze 1 bis zum vorletzten Platz. Das gefundene Element ist die zweitgrößte Temperatur. Dieses tauscht man dann an den vorletzten Platz. Anschließend wird so mit der nächstkleineren Liste weiter verfahren.
h)
setze [listenlaenge v] auf (Länge von [temperaturen v])
wiederhole bis <(listenlaenge) < (2)>
setze [maxIndex v] auf (1)
setze [max v] auf (Element (1) von [temperaturen v])
setze [index v] auf (1)
wiederhole bis <(index) > (listenlaenge)>
falls <(Element (index) von [temperaturen v]) > (max)> , dann
setze [maxIndex v] auf (index)
setze [max v] auf (Element (index) von [temperaturen v])
end
ändere [index v] um (1)
end
ersetze Element (maxIndex) von [temperaturen v] durch (Element (listenlaenge) von [temperaturen v])
ersetze Element (listenlaenge) von [temperaturen v] durch (max)
ändere [listenlaenge v] um (-1)
end
Das Programm sortiert aufsteigend. Für eine absteigende Sortierung sucht man in jedem Durchlauf statt des Maximums das Minimum (min, minIndex, Vergleich mit „<“) und tauscht es nach hinten. Die Abbruchbedingung listenlaenge < 2 sorgt dafür, dass das Programm auch bei einer leeren Liste endet.
Zusammenfassung: Algorithmische Muster
Fast alle Algorithmen dieser Einheit sind aus wenigen Grundmustern zusammengesetzt. Wenn Sie diese Muster wiedererkennen, können Sie neue Aufgaben schneller lösen. Auch die Übertragung nach Java fällt dann leichter.
1. Liste durchlaufen Eine Indexvariable startet bei 1 und wird in jedem Durchlauf um 1 erhöht, bis sie größer als die Länge der Liste ist.
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
sage (Element (index) von [temperaturen v]) für (1) Sekunden
ändere [index v] um (1)
end
2. Summe und Durchschnitt Die Summe startet vor der Schleife bei 0. In jedem Durchlauf wird das aktuelle Element addiert. Nach der Schleife wird durch die Länge geteilt.
setze [summe v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
ändere [summe v] um (Element (index) von [temperaturen v])
ändere [index v] um (1)
end
setze [durchschnitt v] auf ((summe) / (Länge von [temperaturen v]))
3. Zählen Ein Zähler startet bei 0 und wird nur dann um 1 erhöht, wenn das aktuelle Element eine Bedingung erfüllt.
setze [anzahl v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
falls <(Element (index) von [temperaturen v]) > (33)> , dann
ändere [anzahl v] um (1)
end
ändere [index v] um (1)
end
4. Maximum suchen Das erste Element ist der vorläufige Höchstwert. Ist ein späteres Element größer, wird es zum neuen Höchstwert, und sein Index wird gespeichert.
setze [max v] auf (Element (1) von [temperaturen v])
setze [maxIndex v] auf (1)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [temperaturen v])>
falls <(Element (index) von [temperaturen v]) > (max)> , dann
setze [max v] auf (Element (index) von [temperaturen v])
setze [maxIndex v] auf (index)
end
ändere [index v] um (1)
end
5. Zwei Elemente tauschen Bevor ein Element überschrieben wird, wird es in einer Hilfsvariablen zwischengespeichert.
setze [hilf v] auf (Element (a) von [temperaturen v])
ersetze Element (a) von [temperaturen v] durch (Element (b) von [temperaturen v])
ersetze Element (b) von [temperaturen v] durch (hilf)
Muster als Struktogramm
Ein Struktogramm stellt einen Algorithmus unabhängig von einer Programmiersprache dar. Es ist deshalb eine gute Brücke zwischen Scratch und Java. Das Beispiel zeigt das Muster „Zählen“. Beachten Sie: Im Struktogramm steht im Schleifenkopf wie in Java die Laufbedingung („solange …“), nicht die Abbruchbedingung aus Scratch. Wie in den Abiturprüfungen steht über dem Struktogramm der Kopf der Operation mit Eingabe und Rückgabetyp. Das Ergebnis wird mit „gib … zurück“ zurückgegeben.
zaehleHitzefrei(temperaturen: Liste vom Inhaltstyp Fließkommazahl): Ganzzahl
anzahl ← 0
index ← 1 // erste Position einer Liste: 1
solange index ≤ Länge von temperaturen
Element an Position index von temperaturen > 33wahrfalsch
anzahl ← anzahl + 1
index ← index + 1
gib anzahl zurück
Struktogramm zum Muster „Zählen“
Probieren Sie es selbst: Stellen Sie das Muster „Summe und Durchschnitt“ als Struktogramm der Operation durchschnitt(temperaturen: Liste vom Inhaltstyp Fließkommazahl): Fließkommazahldar.
Datentypen in Scratch
Datentyp
Beispiele
Worauf Sie achten sollten
Zahl
25, 27.5, −3
Dezimalzahlen werden mit Punkt geschrieben: 27.5 statt 27,5. In Java unterscheidet man Ganzzahlen (int) und Dezimalzahlen (float oder double).
Text
„Hitzefrei!“, die Antwort eines „frage“-Blocks
Die Antwort eines „frage“-Blocks ist immer ein Text. Scratch wandelt sie zum Rechnen automatisch in eine Zahl um. In Java muss man diese Umwandlung selbst programmieren.
Wahrheitswert
wahr, falsch (Ergebnis eines sechseckigen Bedingungsblocks)
Eine eingetippte Antwort „wahr“ ist in Scratch ein Text und kein Wahrheitswert. In Java heißt der Datentyp boolean mit den Werten true und false.
Liste
temperaturen
Eine Liste speichert viele Werte unter einem Namen. Jedes Element hat einen Index. In Scratch beginnt er bei 1, bei der Java-Klasse Liste dagegen bei 0.
Ausblick auf Java: zwei Stolpersteine
1. „wiederhole bis“ und „solange“: Scratch prüft im Schleifenkopf eine Abbruchbedingung: Die Schleife läuft, bis die Bedingung wahr wird. Java prüft mit while eine Laufbedingung: Die Schleife läuft, solange die Bedingung wahr ist. Beim Übertragen muss die Bedingung deshalb umgekehrt werden.
wiederhole bis <(index) > (laenge)>
ändere [index v] um (1)
end
Scratch: wiederhole, bis index größer als laenge ist
while (index <= laenge) {
index = index + 1;
}
Java: wiederhole, solange index kleiner oder gleich laenge ist
2. Der erste Index: In Scratch hat das erste Element einer Liste den Index 1. Die Klasse Liste, die Sie in Java nutzen, beginnt dagegen bei 0 – wie Java-Arrays und viele andere Programmiersprachen. Beim Übertragen ändern sich deshalb Startwert und Bedingung: index startet bei 0, und die Schleife läuft, solange index < laenge gilt. Das letzte Element hat dann den Index laenge - 1.
Checkliste: Das kann ich jetzt
Übungsaufgaben zu Scratch
Diese Übungsaufgaben eignen sich zur Vorbereitung auf eine Klausur oder als Hausaufgabe.
Ihr Bearbeitungsfortschritt:0%
Aufgabe 1 (Programmanalyse)
Die folgenden Aufgabenteile sind unabhängig vom bisherigen Kontext und dienen zur Übung.
Der folgende Algorithmus soll für die Liste zahlen mit den Werten 15.5, −17.2, 0.0, −18.0, 19.1, −20.3, 21.0 die Anzahl der negativen Werte ermitteln.
setze [anzahlNegativ v] auf (0)
setze [aktuell v] auf [ ]
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [zahlen v])>
setze [aktuell v] auf (Element (index) von [zahlen v])
falls <<(aktuell) < (0)> oder <(aktuell) = (0)>> , dann
ändere [anzahlNegativ v] um (1)
end
ändere [index v] um (1)
end
sage (verbinde [Die Anzahl negativer Zahlen ist: ] und (anzahlNegativ)) für (2) Sekunden
Die folgende Tabelle nennt man Tracetabelle. Eine neue Zeile wird am Ende eines Schleifendurchlaufs der „wiederhole bis“-Schleife ausgefüllt. Am Ende des ersten Durchlaufs wurde bereits die erste Zeile ausgefüllt.
Schleifendurchlauf
index
aktuell
anzahlNegativ
1
2
15.5
0
Identifizieren Sie mithilfe der Tabelle die Stelle, an der der Algorithmus nicht wie gewünscht arbeitet, und korrigieren Sie den Algorithmus entsprechend.
Der folgende Algorithmus soll für eine Liste zahlen mit den Werten 3, 7, 10, 5, 1, 12 den Durchschnitt ermitteln.
setze [summe v] auf (0)
setze [durchschnitt v] auf [ ]
setze [index v] auf (1)
wiederhole bis <(index) = (Länge von [zahlen v])>
ändere [summe v] um (Element (index) von [zahlen v])
ändere [index v] um (1)
end
setze [durchschnitt v] auf ((summe) / (6))
sage (verbinde [Der Durchschnitt ist: ] und (durchschnitt)) für (2) Sekunden
Identifizieren Sie mithilfe der unten abgebildeten Tracetabelle die Stelle(n), an der bzw. denen der Algorithmus nicht wie gewünscht arbeitet, und korrigieren Sie den Algorithmus entsprechend.
Eine neue Zeile wird am Ende eines Schleifendurchlaufs der „wiederhole bis“-Schleife ausgefüllt. Außerdem soll eine Zeile am Ende des Programms ausgefüllt werden.
Schleifendurchlauf
index
summe
durchschnitt
Der folgende Algorithmus soll die Werte einer Liste zahlen mit den Werten 4, 8, 15, 16, 23 rückwärts in eine zweite Liste zahlenRueckwaerts eintragen.
setze [index v] auf (Länge von [zahlen v])
wiederhole bis <(index) > (Länge von [zahlen v])>
setze [aktuell v] auf (Element (index) von [zahlen v])
füge (aktuell) zu [zahlenRueckwaerts v] hinzu
ändere [index v] um (1)
end
Identifizieren Sie mithilfe der unten abgebildeten Tracetabelle die Stelle(n), an der bzw. denen der Algorithmus nicht wie gewünscht arbeitet, und korrigieren Sie den Algorithmus entsprechend.
Eine neue Zeile wird am Ende eines Schleifendurchlaufs der „wiederhole bis“-Schleife ausgefüllt. In der Spalte zahlenRueckwaerts soll die komplette Liste nach jedem Schleifendurchlauf eingetragen werden.
Schleifendurchlauf
index
aktuell
zahlenRueckwaerts
Der folgende Algorithmus soll in einer Liste zahlen mit den Werten 15, 4, 2, 1, 6 alle Zahlen löschen, die kleiner als 5 sind.
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [zahlen v])>
setze [aktuell v] auf (Element (index) von [zahlen v])
falls <(aktuell) < (5)> , dann
lösche (index) aus [zahlen v]
end
ändere [index v] um (1)
end
Identifizieren Sie mithilfe der unten abgebildeten Tracetabelle die Stelle(n), an der bzw. denen der Algorithmus nicht wie gewünscht arbeitet, und korrigieren Sie den Algorithmus entsprechend.
Eine neue Zeile wird am Ende eines Schleifendurchlaufs der „wiederhole bis“-Schleife ausgefüllt. In der Spalte zahlen soll die komplette Liste nach jedem Schleifendurchlauf eingetragen werden.
Schleifendurchlauf
index
aktuell
Länge von zahlen
zahlen
Es liegen zwei Listen vor. In der Liste waren sind verschiedene Produkte gespeichert. In einer zweiten Liste mengen sind die dazugehörigen Lagermengen gespeichert. Ein Produkt am Index i der Liste waren hat seine Lagermenge am Index i der Liste mengen.
Der folgende Algorithmus soll überprüfen, ob ein bestimmtes Produkt vorhanden ist. Wenn das der Fall ist, wird die Lagermenge um 10 erhöht. Wenn nicht, wird es am Ende der Liste waren eingefügt und eine Lagermenge von 5 angelegt. Die Listen liegen wie folgt vor:
setze [gefunden v] auf [wahr]
frage [Was suchst du?] und warte
setze [gesucht v] auf (Antwort)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [waren v])>
falls <(Element (index) von [waren v]) = (gesucht)> , dann
ersetze Element (index) von [mengen v] durch [+10]
setze [gefunden v] auf [wahr]
end
ändere [index v] um (1)
end
falls <(gefunden) = [falsch]> , dann
füge (gesucht) zu [waren v] hinzu
füge (5) zu [mengen v] hinzu
end
Identifizieren Sie mithilfe der unten abgebildeten Tracetabelle die Stelle(n), an der bzw. denen der Algorithmus nicht wie gewünscht arbeitet, und korrigieren Sie den Algorithmus entsprechend. Hierfür können Sie einmal eine Tracetabelle für den Fall, dass „Banane“ gesucht wird, und eine zweite Tabelle für den Fall, dass „Kiwi“ gesucht wird, erstellen.
Eine neue Zeile wird am Ende eines Schleifendurchlaufs der „wiederhole bis“-Schleife ausgefüllt. Außerdem noch eine Zeile am Ende des Programms.
Tracetabelle für „Banane“
Schleifendurchlauf
index
gesucht
gefunden
waren
mengen
Tracetabelle für „Kiwi“
Schleifendurchlauf
index
gesucht
gefunden
waren
mengen
Aufgabe 2 (Implementierung)
Die folgenden Aufgabenteile sind unabhängig vom bisherigen Kontext und dienen zur Übung. Bearbeiten Sie diese in einer eigenen Scratch-Datei. Für jeden Aufgabenteil können Sie einen eigenen Startblock definieren, z. B. den „Wenn Taste a gedrückt wird“-Block für Aufgabenteil a).
Erstellen Sie eine neue Liste werte und fügen Sie mit einer Schleife 30 zufällige Zahlen zwischen −10 und +10 ein.
Erweitern Sie Ihr Programm so, dass die Summe und der Durchschnitt der Zahlen ermittelt und ausgegeben werden.
Erstellen Sie eine neue Liste namens zahlen und füllen Sie sie mit 20 zufälligen Ganzzahlen zwischen 0 und 50.
Erweitern Sie Ihr Programm so, dass das größte Element (Maximum) und das kleinste Element (Minimum) aus der Liste ermittelt und ausgegeben werden.
Erstellen Sie eine neue Liste namens werte und füllen Sie sie mit 40 zufälligen Zahlen im Bereich von −20 bis +20.
Ergänzen Sie Ihr Programm, sodass gezählt wird, wie viele Werte negativ, wie viele positiv und wie viele gleich null sind. Geben Sie diese Anzahlen anschließend aus.
Erstellen Sie eine neue Liste schuelerPunkte und füllen Sie diese mit 25 zufälligen Zahlen zwischen 0 und 100 (jede Zahl repräsentiert einen erzielten Punktwert).
Erweitern Sie Ihr Programm so, dass es
die Summe und den Durchschnitt aller Punktwerte berechnet und ausgibt,
zählt, wie viele Schülerinnen und Schüler mehr als 75 Punkte erreicht haben, und diese Anzahl ausgibt.
Erstellen Sie eine Liste zufallszahlen und füllen Sie sie mit 15 zufälligen Zahlen zwischen −50 und +50.
Erstellen Sie eine zweite Liste quadrate, in der Sie für jedes Element aus der ersten Liste den quadrierten Wert berechnen und speichern.
Geben Sie beide Listen sowie die Summe aller Elemente in der Liste quadrate aus.
Aufgabe 3 (Größere Aufgabe)
In einer Liste noten sind die Noten (1 bis 6) einer Klasse gespeichert. Der Index steht jeweils für eine Schülerin oder einen Schüler. Ein Programm soll die Liste auswerten und zum Beispiel
den Durchschnitt der Noten berechnen,
zählen, wie viele Schülerinnen und Schüler eine schlechtere Note als einen festgelegten Schwellenwert (z. B. 3) haben,
das Ergebnis (Durchschnittsnote und Anzahl der Schülerinnen und Schüler über dem Schwellenwert) ausgeben,
usw.
Erläutern Sie, warum es sinnvoll ist, die Noten in einer Liste zu speichern, anstatt für jede Person separate Variablen zu verwenden.
Implementieren Sie ein Programm in Scratch, welches aus einer gegebenen Liste noten, in der eine unbekannte Anzahl Noten gespeichert ist, die Durchschnittsnote berechnet und am Ende in einem vollständigen Satz ausgibt.
Die Nummern (Indizes) der Schülerinnen und Schüler, die eine Note 5 oder 6 haben, sollen in einer weiteren Liste gefaehrdet gespeichert und am Schluss ausgegeben werden. In Abbildung 1 ist ein Vorschlag für ein solches Programm gegeben.
Wenn ⚑ angeklickt wird
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [noten v])>
falls <(Element (index) von [noten v]) > (5)> , dann
füge (Element (index) von [noten v]) zu [gefaehrdet v] hinzu
end
ändere [index v] um (1)
end
wiederhole bis <(index) > (Länge von [noten v])>
sage (verbinde [Gefährdete Schülernummer: ] und (Nummer von (index) in [gefaehrdet v])) für (2) Sekunden
ändere [index v] um (1)
end
Abbildung 1: Vorschlag zum Programm für gefährdete Schülerinnen und Schüler
Analysieren Sie die Funktionsweise des Programms. Erläutern und korrigieren Sie eventuelle Fehler.
Implementieren Sie einen Algorithmus in Scratch, der zählt, wie viele Schülerinnen und Schüler besser als der vorher berechnete Durchschnitt sind (also einen kleineren Notenwert als durchschnitt haben), und diese Anzahl am Schluss in einem vollständigen Satz ausgibt. Den Durchschnittswert durchschnitt können Sie in Ihrem Algorithmus direkt nutzen.
Hier finden Sie mögliche Lösungen zu den Übungsaufgaben.
Die Lösungen enthalten auch die ausgefüllten Tracetabellen.
Aufgabe 1
a)
Schleifendurchlauf
index
aktuell
anzahlNegativ
1
2
15.5
0
2
3
−17.2
1
3
4
0.0
2
4
5
−18.0
3
5
6
19.1
3
6
7
−20.3
4
7
8
21.0
4
In der 3. Zeile der Tracetabelle wird anzahlNegativ fälschlich erhöht, weil die Bedingung auch bei aktuell = 0 erfüllt ist. Richtig ist die Bedingung aktuell < 0.
b)
Schleifendurchlauf
index
summe
durchschnitt
1
2
3
–
2
3
10
–
3
4
20
–
4
5
25
–
5
6
26
–
–
6
26
4.333…
Die Liste wird nicht komplett durchlaufen, da die Abbruchbedingung falsch ist. Es müsste index > Länge von zahlen sein. Außerdem wird durch die feste Zahl 6 geteilt. Das funktioniert nur, solange die Liste genau sechs Elemente hat. Besser ist summe / Länge von zahlen.
c)
Schleifendurchlauf
index
aktuell
zahlenRueckwaerts
1
6
23
23
Die Schleife bricht nach einem Durchlauf ab, weil index danach größer als die Länge der Liste ist. Zwei Änderungen sind notwendig: index muss am Ende der Schleife um 1 gesenkt statt erhöht werden, und die Abbruchbedingung muss index < 1 lauten. Ändert man nur die Schrittweite, wird index > Länge von zahlen nie wahr und es entsteht eine Endlosschleife.
setze [index v] auf (Länge von [zahlen v])
wiederhole bis <(index) < (1)>
setze [aktuell v] auf (Element (index) von [zahlen v])
füge (aktuell) zu [zahlenRueckwaerts v] hinzu
ändere [index v] um (-1)
end
Korrigierter Algorithmus
d)
Schleifendurchlauf
index
aktuell
Länge von zahlen
zahlen
1
2
15
5
15, 4, 2, 1, 6
2
3
4
4
15, 2, 1, 6
3
4
1
3
15, 2, 6
Die Schleife überspringt Listenelemente: Nach dem Löschen der 4 rückt die 2 auf Platz 2 nach, index wird aber trotzdem auf 3 erhöht. Die 2 wird deshalb nie geprüft und bleibt in der Liste (Ergebnis: 15, 2, 6). Abhilfe: index nur dann um 1 erhöhen, wenn nichts gelöscht wurde, also das Erhöhen in einen sonst-Zweig verschieben. Möglich wäre auch, index nach einer Löschung auf 0 zu setzen, weil er am Ende des Schleifendurchlaufs noch um 1 erhöht wird. Dann wird die Liste aber jedes Mal von vorn durchlaufen.
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [zahlen v])>
setze [aktuell v] auf (Element (index) von [zahlen v])
falls <(aktuell) < (5)> , dann
lösche (index) aus [zahlen v]
sonst
ändere [index v] um (1)
end
end
Korrigierter Algorithmus
e)
Tracetabelle für „Banane“
Schleifendurchlauf
index
gesucht
gefunden
waren
mengen
1
2
Banane
wahr
„Apfel“, „Banane“, „Orange“
10, 5, 8
2
3
Banane
wahr
„Apfel“, „Banane“, „Orange“
10, +10, 8
3
4
Banane
wahr
„Apfel“, „Banane“, „Orange“
10, +10, 8
–
4
Banane
wahr
„Apfel“, „Banane“, „Orange“
10, +10, 8
Die Lagermenge wird falsch geändert: ersetze … durch [+10] speichert den Text „+10“, statt 10 zu addieren. Richtig ist ersetze Element (index) von mengen durch ((Element (index) von mengen) + 10).
Tracetabelle für „Kiwi“
Schleifendurchlauf
index
gesucht
gefunden
waren
mengen
1
2
Kiwi
wahr
„Apfel“, „Banane“, „Orange“
10, 5, 8
2
3
Kiwi
wahr
„Apfel“, „Banane“, „Orange“
10, 5, 8
3
4
Kiwi
wahr
„Apfel“, „Banane“, „Orange“
10, 5, 8
–
4
Kiwi
wahr
„Apfel“, „Banane“, „Orange“
10, 5, 8
Kiwi gibt es nicht in waren, aber das Produkt wird nicht hinzugefügt, da gefunden „wahr“ ist. Das Problem ist, dass gefunden zu Beginn mit „falsch“ starten muss und nur, wenn das Produkt vorhanden ist, auf „wahr“ gesetzt werden soll.
Aufgabe 2
a)
Wenn Taste [a v] gedrückt wird
lösche alles aus [werte v]
wiederhole (30) mal
füge (Zufallszahl von (-10) bis (10)) zu [werte v] hinzu
end
setze [summe v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [werte v])>
ändere [summe v] um (Element (index) von [werte v])
ändere [index v] um (1)
end
setze [durchschnitt v] auf ((summe) / (Länge von [werte v]))
sage (verbinde [Die Summe ist: ] und (summe)) für (2) Sekunden
sage (verbinde [Der Durchschnitt ist: ] und (durchschnitt)) für (2) Sekunden
b)
Wenn Taste [b v] gedrückt wird
lösche alles aus [zahlen v]
wiederhole (20) mal
füge (Zufallszahl von (0) bis (50)) zu [zahlen v] hinzu
end
setze [max v] auf (Element (1) von [zahlen v])
setze [min v] auf (Element (1) von [zahlen v])
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [zahlen v])>
falls <(Element (index) von [zahlen v]) < (min)> , dann
setze [min v] auf (Element (index) von [zahlen v])
end
falls <(Element (index) von [zahlen v]) > (max)> , dann
setze [max v] auf (Element (index) von [zahlen v])
end
ändere [index v] um (1)
end
sage (verbinde [Das Minimum ist: ] und (min)) für (2) Sekunden
sage (verbinde [Das Maximum ist: ] und (max)) für (2) Sekunden
c)
Wenn Taste [c v] gedrückt wird
lösche alles aus [werte v]
wiederhole (40) mal
füge (Zufallszahl von (-20) bis (20)) zu [werte v] hinzu
end
setze [anzahlNegativ v] auf (0)
setze [anzahlPositiv v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [werte v])>
falls <(Element (index) von [werte v]) < (0)> , dann
ändere [anzahlNegativ v] um (1)
end
falls <(Element (index) von [werte v]) > (0)> , dann
ändere [anzahlPositiv v] um (1)
end
ändere [index v] um (1)
end
setze [anzahlNull v] auf (((Länge von [werte v]) - (anzahlPositiv)) - (anzahlNegativ))
sage (verbinde [Anzahl der negativen Zahlen: ] und (anzahlNegativ)) für (2) Sekunden
sage (verbinde [Anzahl der positiven Zahlen: ] und (anzahlPositiv)) für (2) Sekunden
sage (verbinde [Anzahl der Zahlen, die 0 sind: ] und (anzahlNull)) für (2) Sekunden
d)
Wenn Taste [d v] gedrückt wird
lösche alles aus [schuelerPunkte v]
wiederhole (25) mal
füge (Zufallszahl von (0) bis (100)) zu [schuelerPunkte v] hinzu
end
setze [summe v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [schuelerPunkte v])>
ändere [summe v] um (Element (index) von [schuelerPunkte v])
ändere [index v] um (1)
end
setze [durchschnitt v] auf ((summe) / (Länge von [schuelerPunkte v]))
sage (verbinde [Die Summe ist: ] und (summe)) für (2) Sekunden
sage (verbinde [Der Durchschnitt ist: ] und (durchschnitt)) für (2) Sekunden
setze [index v] auf (1)
setze [anzahl v] auf (0)
wiederhole bis <(index) > (Länge von [schuelerPunkte v])>
falls <(Element (index) von [schuelerPunkte v]) > (75)> , dann
ändere [anzahl v] um (1)
end
ändere [index v] um (1)
end
sage (verbinde [So viele Lernende haben mehr als 75 Punkte erreicht: ] und (anzahl)) für (2) Sekunden
e)
Wenn Taste [e v] gedrückt wird
lösche alles aus [zufallszahlen v]
lösche alles aus [quadrate v]
wiederhole (15) mal
füge (Zufallszahl von (-50) bis (50)) zu [zufallszahlen v] hinzu
end
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [zufallszahlen v])>
füge ((Element (index) von [zufallszahlen v]) * (Element (index) von [zufallszahlen v])) zu [quadrate v] hinzu
ändere [index v] um (1)
end
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [zufallszahlen v])>
sage (Element (index) von [zufallszahlen v]) für (1) Sekunden
ändere [index v] um (1)
end
setze [summe v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [quadrate v])>
ändere [summe v] um (Element (index) von [quadrate v])
ändere [index v] um (1)
end
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [quadrate v])>
sage (Element (index) von [quadrate v]) für (1) Sekunden
ändere [index v] um (1)
end
sage (verbinde [Die Summe der Quadrate ist: ] und (summe)) für (2) Sekunden
Aufgabe 3
a) Vorteile der Verwendung von Listen
Strukturierte Datenspeicherung: Wird eine Liste verwendet, können alle Noten der Schüler in einer einheitlichen Datenstruktur abgelegt werden.
Einfaches Durchlaufen: Mit einer Schleife kann man jeden Wert der Liste abarbeiten, was besonders beim Berechnen des Mittelwerts oder beim Zählen bestimmter Noten sehr hilfreich ist.
Erweiterbarkeit: Falls später mehr Schülerdaten hinzukommen, muss die Datenstruktur nicht angepasst werden – es wird einfach ein neues Element angehängt.
Indizierung: Die Noten werden direkt mit einem Index, z. B. für eine Nummerierung der Schülerinnen und Schüler, gespeichert.
b)
Zusätzlich erstellte Variablen: summe, durchschnitt und index.
Wenn ⚑ angeklickt wird
setze [summe v] auf (0)
setze [durchschnitt v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [noten v])>
ändere [summe v] um (Element (index) von [noten v])
ändere [index v] um (1)
end
setze [durchschnitt v] auf ((summe) / (Länge von [noten v]))
sage (verbinde [Die Durchschnittsnote ist: ] und (durchschnitt)) für (2) Sekunden
Lösung in Scratch
Wenn ⚑ angeklickt
setze summe auf 0
setze durchschnitt auf 0
setze index auf 1
wiederhole bis (index > Länge von noten)
ändere summe um Element index von noten
ändere index um 1
setze durchschnitt auf summe / Länge von noten
sage (verbinde "Die Durchschnittsnote ist: " und durchschnitt) für 2 Sekunden
Lösung als Text
c) Analyse und Korrektur eines Programms zur Erfassung gefährdeter Schülerinnen und Schüler
Das vorliegende Programm soll die Nummern der Schülerinnen und Schüler, die eine Note 5 oder 6 haben, in einer weiteren Liste gefaehrdet speichern und diese Liste am Ende ausgeben.
Aufbau des Programms:
Es wird mit dem Wert 1 ein Index initialisiert.
In einer Schleife wird überprüft, ob das Element an der Stelle index in der Liste noten die Note 5 oder 6 enthält.
Falls die Bedingung erfüllt ist, soll das Element (oder die Schülernummer) zur Liste gefaehrdet hinzugefügt werden.
Fehler:
Bedingung für die Noten 5 und 6 hinter „falls“: Aktuell wird nur die Note 6 erfasst. Die Bedingung muss Element index von noten > 4 sein.
Einfügen in die Liste gefaehrdet: Aktuell werden die Noten in gefaehrdet eingefügt. Es müssen nur die index-Werte sein: füge index zu gefaehrdet hinzu.
Index-Wert nach der ersten Schleife: Es muss sichergestellt werden, dass index nach der ersten Schleife wieder auf 1 gesetzt wird, da der Wert von index nach der ersten Schleife der Länge der Liste noten + 1 entspricht und die zweite Schleife sonst kein einziges Mal durchlaufen wird.
Abbruchbedingung im zweiten Schleifenkopf: Aktuell wird index > Länge von noten geprüft. Die Liste gefaehrdet enthält nur einen Teil der Werte aus noten und ist potenziell deutlich kleiner. Deshalb muss die Abbruchbedingung index > Länge von gefaehrdet sein.
Ausgabe in der zweiten Schleife: Aktuell wird der Block Nummer von index in gefaehrdet genutzt. Dieser Block gibt den Index eines gesuchten Elements einer Liste zurück. Das ist hier falsch. Anstelle dieses Blocks müsste es Element index von gefaehrdet sein.
d)
Zusätzlich erstellte Variablen: anzahl, index.
setze [anzahl v] auf (0)
setze [index v] auf (1)
wiederhole bis <(index) > (Länge von [noten v])>
falls <(Element (index) von [noten v]) < (durchschnitt)> , dann
ändere [anzahl v] um (1)
end
ändere [index v] um (1)
end
sage (verbinde (verbinde (anzahl) und [ Schülerinnen und Schüler haben eine bessere Note als der Durchschnitt von ]) und (durchschnitt)) für (2) Sekunden
Lösung in Scratch
setze anzahl auf 0
setze index auf 1
wiederhole bis (index > Länge von noten)
falls Element index von noten < durchschnitt, dann
ändere anzahl um 1
ändere index um 1
sage (verbinde (verbinde anzahl und " Schülerinnen und Schüler haben eine bessere Note
als der Durchschnitt von ") und durchschnitt) für 2 Sekunden