12.1.2 Tracetabelle

• Starten Sie das Programm Blockly-Trace-Editor oder löschen Sie das aktuelle Programm durch einen Klick auf "Programm löschen", wenn der Blockly-Trace-Editor noch geöffnet ist.

• Bauen Sie folgendes Programm und erzeugen Sie die vollständige Tracetabelle:

Bei solchen einfachen Veränderung von "a" kann unser Gehirn noch mitdenken. Bei komplizierteren Algorithmen ist es hilfreich, wenn man sieht, bei welcher Wiederholung, die Variable "a" einen bestimmten Wert hatte. Dazu verwendet man den Schleifenblock "zähle ... von ... bis" bei welchem eine Zählvariable verwendet wird, die ihren Wert bei jedem Durchlauf der Schleife verändert.

Damit beide Variablen in der Trace-Tabelle angezeigt werden, muss der Block "Trace-Eintrag dazu" mit der Variablen "i" ergänzt werden.

• Klicken Sie auf das Zahnradsymbol im Block "Trace-Eintrag dazu" und schieben Sie von der linken Spalte einen Block "Element" innerhalb von "verbinden".

• Ergänzen Sie den Block mit der Variablen "i", so dass folgende Trace-Tabelle erzeugt wird, wenn Sie wiederholt auf "nächster Schritt" klicken:

Wenn man im Block "Trace-Eintrag dazu" eine Variable andockt, die noch keinen Wert hat, dann wird in der Trace-Tabelle nichts angezeigt.

• Wenn etwas nicht klappt, können Sie das Programm auch laden: Schleife.

• Starten Sie das Programm p5js-Text-Editor

• Geben Sie folgenden Programmtext ein (z.B. mit Copy/Paste):

var a, i;

a = 0;
console.log({Eintrag:"t1", i:i, a:a});
for (i = 1; i <= 10; i = i + 1) {
  a = a + 10;
  console.log({Eintrag:"t2", i:i, a:a});
}

Erklärung:

• Mit var a, i; werden die Variablen "a" und "i" ohne eine Wertzuordnung festgelegt.

• Mit a = 0; wird der Variablen "a" der Wert 0 zugeordnet.

• Mit for (i = 1; i <= 10; i = i + 1) { ... } werden die Anweisungen zwischen den geschweiften Klammern so oft ausgeführt, bis die Variable "i" den Wert 10 erreicht hat. Bei jedem Schleifendurchlauf wird die Variable "i" um eins erhöht.

• Mit a = a + 10; wird der aktuelle Wert von "a" mit 10 addiert.

• Mit console.log({Eintrag:"t1", a:a}); wird der aktuelle Wert von "a" in der Konsole ausgegeben. Um die Konsole anzuzeigen, klicken Sie unten auf die Leiste mit der Beschriftung "CONSOLE". Sie sehen in der Konsole alle Werte der Variablen "a", die sie in den verschiedenen Zuständen während der Programmausführung hatte:

Die Fibonacci-Zahlenfolge ist eine berühmte Folge von Zahlen:

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 …

Sie entsteht, indem ab der dritten Zahl eine neue Zahl in der Zahlenfolge die Summe der beiden letzten bereits vorhandenen Zahlen ist:

2 = 1 + 1; 3 = 2 + 1; 5 = 3 + 2; 8 = 5 + 3; ...

Ein Algorithmus, um diese Zahlenfolge zu erzeugen, kann wie folgt beschrieben werden:

• Lege drei Variablen "neueZahl = 1", "v1 = 0", "v2 = 1" fest
• Wiederhole von i = 2 bis 15:
  • neueZahl = v1 + v2
  • v1 = v2
  • v2 = neue Zahl

Erstellen Sie ein Block- oder Text-Programm, das diesen Algorithmus auführen kann und erzeugen Sie eine Trace-Tabelle mit den ersten 15 Zahlen der Fibonacci-Folge.

Lösungs-Programm starten: Fibonacci.

Programmcode einer möglichen Lösung:

var neueZahl, v1, v2, i;

neueZahl = 1;
v1 = 0;
v2 = 1;
console.log({Eintrag:"t1", i:i, v1:v1, v2:v2, neueZahl:neueZahl});
for (i = 2; i <= 15; i = i + 1) {
  neueZahl = v1 + v2;
  v1 = v2;
  v2 = neueZahl;
  console.log({Eintrag:"t2", i:i, v1:v1, v2:v2, neueZahl:neueZahl});
}

Lösungs-Programm laden: Fibonacci

var zListe = [3, 9, 7, 1, 4];

zahl1 = zListe[0];
zahl2 = zListe[1];
zahl3 = zListe[2];
zahl4 = zListe[3];
zahl5 = zListe[4];

• Starten Sie folgendes Programm: Elemente in Liste ändern.

var liste;

liste = [3, 9, 7, 1, 4];
liste[0] = 23;
liste[1] = 153;
liste[2] = 0.754;
liste[3] = 43;
liste[4] = 17;

Das folgende Beispiel funktioniert wie folgt:

• Zuerst wird eine Liste mit zwei Zufallszahlen erzeugt.
• Dann wird mit einer Falls-Abfrage geprüft, ob die Zahl beim Index 0 größer ist als die Zahl beim Index 1.
• Wenn ja:
  • der Inhalt von Index 1 wird in eine Hilfsvariable namens "temp" gespeichert,
  • in Index 0 wird der Inhalt von Index 1 gespeichert,
  • in Index 1 wird der Inhalt von "temp" gespeichert.
• Wenn nein:
  • dann wird nichts gemacht

• Sortier-Programm starten: Zwei Zahlen sortieren.

Das folgende Beispiel funktioniert wie folgt:

• Zuerst wird eine Liste mit zwei Zufallszahlen erzeugt. Dazu wird der Zufallsgenerator verwendet, der im letzten Kapitel entwickelt wurde.
• Dann wird mit einer if-Abfrage geprüft, ob die Zahl beim Index 0 größer ist als die Zahl beim Index 1.
• Wenn ja:
  • der Inhalt von Index 1 wird in eine Hilfsvariable namens "temp" gespeichert,
  • in Index 0 wird der Inhalt von Index 1 gespeichert,
  • in Index 1 wird der Inhalt von "temp" gespeichert.
• Wenn nein:
  • dann wird nichts gemacht

Programm-Code:

var liste, temp;

function mathRandomInt(a, b) {
  if (a > b) {
    // Swap a and b to ensure a is smaller.
    var c = a;
    a = b;
    b = c;
  }
  return Math.floor(Math.random() * (b - a + 1) + a);
}

liste = [mathRandomInt(1, 100), mathRandomInt(1, 100)];
if (liste[0] > liste[1]) {
  temp = liste[0];
  liste[0] = liste[1];
  liste[1] = temp;
}

Das folgende Beispiel funktioniert wie folgt:

• Zuerst wird eine Liste mit fünf Zufallszahlen erzeugt.
• Mit Hilfe von zwei Wiederholungsschleifen werden die Zahlen solange durchlaufen, bis sie der Größe nach sortiert sind.
• Dazu wird mit einer Falls-Abfrage geprüft, ob die Zahl beim Index 0 größer ist als die Zahl beim Index 1.
• Wenn ja:
  • der Inhalt von Index 1 wird in eine Hilfsvariable namens "temp" gespeichert,
  • in Index 0 wird der Inhalt von Index 1 gespeichert,
  • in Index 1 wird der Inhalt von "temp" gespeichert.
• Wenn nein:
  • dann wird nichts gemacht

• Sortier-Programm starten: Bubble-Sort.

Das folgende Beispiel funktioniert wie folgt:

• Zuerst wird eine Liste mit zwei Zufallszahlen erzeugt. Dazu wird der Zufallsgenerator verwendet, der im letzten Kapitel entwickelt wurde.
• Mit Hilfe von zwei Wiederholungsschleifen werden die Zahlen solange durchlaufen, bis sie der Größe nach sortiert sind.
• Dazu wird mit einer if-Abfrage geprüft, ob die Zahl beim Index 0 größer ist als die Zahl beim Index 1.
• Wenn ja:
  • der Inhalt von Index 1 wird in eine Hilfsvariable namens "temp" gespeichert,
  • in Index 0 wird der Inhalt von Index 1 gespeichert,
  • in Index 1 wird der Inhalt von "temp" gespeichert.
• Wenn nein:
  • dann wird nichts gemacht

Programm-Code:

var zListe, i, j, temp;

zListe = [3, 9, 7, 1, 4];
for (i = 0; i < zListe.length; i = i + 1) {
  for (j = 0; j < zListe.length; j = j + 1) {
    if (zListe[j] > zListe[(j + 1)]) {
      temp = zListe[j];
      zListe[j] = zListe[(j + 1)];
      zListe[(j + 1)] = temp;
    }
  }
}

Der erste Sortieralgorithmus benötigt bei \(n\) Zahlen \(n^2\) Schleifen-Wiederholungen. Das kann bei großen Zahlenmengen, die sortiert werden sollen, schnell sehr viel werden.

Der folgende Algorithmus soll so umgebaut werden, dass erkannt wird, wann die Zahlen sortiert sind und der Algorithmus früher gestoppt wird.

• Sortier-Programm starten: Bubble-Sort.

Lösungs-Programm starten: Bubble-Sort etwas effizienter.