Web 0.15.1: dritter Tipp für schwere Übungen, VisuBot-Spiel in Lektion 2

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is loosely inspired by Keep a Changelog.
 
 ### Changed
 
+- **Web 0.15.1, third hint and robot game moved:** eight harder exercises get a third hint that gives the outline of the solution box by box (L9 Schaltjahr, L10 Taschenrechner, L12 Summe bis 0, L14 Rechteck, L15 Summe und Maximum, L17 Rückwärts and Wörter zählen, L19 Absteigend sortieren; de/en/pt, with the variable names of each language). Students working alone are no longer stuck after two hints; the sample solution stays teacher-only. VisuBot: the game „Wo landet der mBot2?“ moves from lesson 1 „Struktogramm und Editor“ (where the commands with numbers in brackets were not explained yet) to lesson 2 „Der mBot2“, right after „Befehle für den mBot2“ and „Erste Fahrt“ (de/en). Saved step positions in these two lessons may shift by one.
 - **Web 0.15.0, release:** version number only, no further changes. 0.15.0 bundles everything since 0.14.x: VisuBot as a robotics-only world with its own basic lessons, a game in every lesson, repaired lesson steps (0.14.34) and lessons that are easier for self-study (0.14.35).
 - **Web 0.14.35, lessons easier for self-study:** VisuBot lesson 3 gets a new step „So sieht Java aus“ before the first Java exercise: where the Code area is, the square with a variable in Java, semicolons, the `for` head, curly brackets, upper and lower case, and how to solve a Java exercise (Im Editor öffnen, type, Prüfen); plus a Kompetenz and checklist item. VisuBot lesson 2 explains the counter `i` of the for loop (what `int i = 0`, `i < 5`, `i++` mean, table of the five runs). VisuBot says `true`/`false` like the editor instead of Ja/Nein (lesson text, hints, tasks). VisuBot lesson 1 (Struktogramm und Editor) says that every exercise ends with Prüfen, often in several worlds, and that the hints help. VisuStruct lesson 4 explains `"Text: " + variable` in the lesson text before the exercise „Rechteck“ (before, only its second hint did). Lesson 2 names the tool buttons Kopieren, Einfügen and Rückgängig for tablets without a keyboard and points to the Simulation button. The tasks of lessons 29–40 get a list „Du bist fertig, wenn …“ with things you can see in the window, so students working alone know when they are done (de/en/pt; VisuBot de/en).
 - **Web 0.14.34, broken lesson steps repaired:** lesson 3 step „Ausprobieren“ ended with „probiere Folgendes aus:“ and no list, and the checklist sat in the same step without its own heading; now there are four things to try (title, save in the workspace, open again in a second tab, export PNG and PDF), the step comes before the game, and „Checkliste“ is its own step (de/en/pt). VisuBot lesson „Sensoren“ step „Was liefert der Sensor?“ had no text; it now explains that a sensor gives a value, that a comparison turns it into `true` or `false` (table with three conditions), the comparison operators and `==` vs. `=` (de/en). The cloze explanation in lesson 4 pointed to a lesson „Java“; it is called „Struktogramm und Code“ (de/en/pt). New tests: the checklist stands in its own step „Checkliste“, and no text ends with a colon with nothing after it.

web/lessons/de/09-bedingungen-verknuepfen.md

@@ -179,6 +179,7 @@ test: 2000 -> Schaltjahr
 braucht: verzweigung
 tipp: Prüfe die Regel zuerst an Beispielen: 2024 ist ein Schaltjahr, 1900 nicht, 2000 schon. Teilbar heißt: Der Rest ist 0.
 tipp: Teilbar durch 4 heißt `jahr % 4 == 0`, nicht teilbar durch 100 heißt `jahr % 100 != 0`. Verbinde diese beiden mit `&&`, setze Klammern darum und hänge mit `||` den Fall für 400 an.
+tipp: Fast die Lösung: Eine einzige Verzweigung mit der Bedingung `(jahr % 4 == 0 && jahr % 100 != 0) || jahr % 400 == 0`. Im true-Zweig steht `output: "Schaltjahr"`, im false-Zweig `output: "kein Schaltjahr"`.
 lösung: l08-schaltjahr-loesung.visustruct
 :::
 

web/lessons/de/10-fallauswahl.md

@@ -76,6 +76,7 @@ test: 1, x, 2 -> Unbekanntes Rechenzeichen
 braucht: fallauswahl
 tipp: Lies erst alle drei Werte ein. Danach entscheidet eine Fallauswahl über das Rechenzeichen, was gerechnet wird.
 tipp: Lege vor der Fallauswahl `int ergebnis = 0` an. In jedem Fall rechnest du zum Beispiel `ergebnis = a + b` und gibst danach `ergebnis` aus. Die Fallnamen sind `"+"`, `"-"` und `"*"` in Anführungszeichen, weil das Rechenzeichen ein `String` ist.
+tipp: Das Gerüst von oben nach unten: drei Eingaben (`int a`, `String zeichen`, `int b`), dann `int ergebnis = 0`, dann eine Fallauswahl über `zeichen`. Im Fall `"+"` stehen `ergebnis = a + b` und `output: ergebnis`, bei `"-"` und `"*"` genauso. Im Sonst-Fall steht `output: "Unbekanntes Rechenzeichen"`.
 lösung: l09-rechner-loesung.visustruct
 :::
 

web/lessons/de/12-do-while-schleife.md

@@ -80,6 +80,7 @@ test: 0 -> 0
 braucht: doUntilSchleife
 tipp: Du brauchst eine Variable für die Summe, die vor der Schleife bei 0 beginnt. In jedem Durchlauf kommt die neue Zahl dazu.
 tipp: Lege vor der Schleife `int summe = 0` und `int zahl = 0` an. In der Schleife fragst du `zahl` ab und rechnest `summe = summe + zahl`. Die 0 zu addieren schadet nicht. Die Schleife läuft weiter, solange `zahl != 0` ist.
+tipp: Das Gerüst: `int summe = 0` und `int zahl = 0`, dann eine Do-while-Schleife mit der Bedingung `zahl != 0`. In ihr stehen die Eingabe von `zahl` und `summe = summe + zahl`. Unter der Schleife steht `output: summe`.
 lösung: l11-summe-loesung.visustruct
 :::
 

web/lessons/de/14-verschachteln.md

@@ -74,6 +74,7 @@ test: 2, 2 -> ## | ##
 braucht: forSchleife
 tipp: Du brauchst zwei Schleifen ineinander: eine für die Zeilen und darin eine für die Zeichen einer Zeile.
 tipp: Baue es wie das Dreieck. Der Unterschied: Die innere Schleife zählt immer bis `breite`, nicht bis zur Zeilennummer. Die äußere Schleife zählt bis `hoehe`.
+tipp: Das Gerüst: Eingaben `breite` und `hoehe`. Äußere For-Schleife `int zeile = 1`, `zeile <= hoehe`, `zeile++`. Darin zuerst `String text = ""`, dann die innere For-Schleife `int spalte = 1`, `spalte <= breite`, `spalte++` mit `text = text + "#"`, und unter der inneren Schleife `output: text`.
 lösung: l13-rechteck-loesung.visustruct
 :::
 

web/lessons/de/15-arrays.md

@@ -148,6 +148,7 @@ test: -5, -2, -9, -1, -3 -> Summe: -20 | Maximum: -1
 braucht: forSchleife, verzweigung
 tipp: Gehe das Array mit einer Schleife durch. Zähle jeden Wert zur Summe und merke dir den größten bisher gesehenen Wert.
 tipp: Rechne Summe und Maximum in eigenen Variablen aus und gib sie erst am Ende aus, z. B. mit `output: "Summe: " + summe`. Beginnt dein Maximum bei 0, scheitert der dritte Test.
+tipp: Das Gerüst: Array anlegen und mit einer Schleife einlesen. Dann `int summe = 0` und `int max = zahlen[0]`. Eine zweite Schleife rechnet `summe = summe + zahlen[i]`, und eine Verzweigung `zahlen[i] > max` setzt im true-Zweig `max = zahlen[i]`. Zum Schluss die beiden Ausgaben.
 lösung: l14-summe-max-loesung.visustruct
 :::
 

web/lessons/de/17-zeichenketten.md

@@ -145,6 +145,7 @@ test: a -> a
 braucht: forSchleife
 tipp: Gehe das Wort Zeichen für Zeichen durch, aber von hinten nach vorn, und baue dabei einen neuen Text zusammen.
 tipp: Lege `String rueckwaerts = ""` an. Die Schleife beginnt beim letzten Index `wort.length() - 1` und zählt mit `i--` bis 0 herunter. In jedem Durchlauf hängst du `wort.charAt(i)` hinten an.
+tipp: Das Gerüst: Eingabe `wort`, dann `String rueckwaerts = ""`. For-Schleife mit Start `int i = wort.length() - 1`, Bedingung `i >= 0` und Schritt `i--`. Darin `rueckwaerts = rueckwaerts + wort.charAt(i)`. Unter der Schleife `output: rueckwaerts`.
 lösung: zk-rueckwaerts-loesung.visustruct
 :::
 
@@ -159,6 +160,7 @@ test: Struktogramme machen Spaß -> Wörter: 3
 braucht: anweisung
 tipp: Zwischen den Wörtern steht immer ein Leerzeichen. Welche Methode zerlegt einen Text an einem Zeichen?
 tipp: Zerlege den Satz mit `satz.split(" ")` in ein String-Array. Seine Länge ist die Anzahl der Wörter.
+tipp: Das ganze Programm hat drei Kästen: die Eingabe `satz`, dann `String[] woerter = satz.split(" ")` und zum Schluss `output: "Wörter: " + woerter.length`.
 lösung: zk-woerter-loesung.visustruct
 :::
 

web/lessons/de/19-suchen-und-sortieren.md

@@ -121,6 +121,7 @@ test: 2, 9, 2, 7, 6 -> 9 | 7 | 6 | 2 | 2
 braucht: forSchleife, verzweigung
 tipp: Schau dir die Bedingung in der Verzweigung an. Sie entscheidet, wann zwei Nachbarn getauscht werden.
 tipp: Du musst nur ein einziges Zeichen ändern. Wann sollen zwei Nachbarn getauscht werden, wenn die größere Karte nach links soll?
+tipp: Ändere in der Verzweigung `karten[i] > karten[i + 1]` in `karten[i] < karten[i + 1]`. Dann wird getauscht, wenn rechts die größere Karte liegt, und die große Karte wandert nach links.
 lösung: ss-absteigend-loesung.visustruct
 :::
 

web/lessons/de/visubot/00-struktogramm-und-editor.md

@@ -118,48 +118,6 @@ richtig: Sequenz
 > Zwei Schritte nacheinander, ohne Bedingung und ohne Wiederholung.
 :::
 
-## Spiel: Wo landet der mBot2?
-
-::: spiel fahrt
-titel: Spiel: Wo landet der mBot2?
-intro: Lies das Programm und tippe auf das Feld, auf dem der mBot2 am Ende steht. Danach fährt er die Strecke vor. Jedes Feld ist 30 cm groß. Vier Runden.
-frage: Auf welchem Feld steht der mBot2 am Ende?
-
-runde:
-    mbot.forward(60);
-    mbot.turnRight();
-    mbot.forward(30);
-karte: ..... | ..... | ..^..
-ziel: 3,0
-> Zwei Felder nach vorn, nach rechts drehen, ein Feld weiter.
-
-runde:
-    mbot.forward(30);
-    mbot.turnLeft();
-    mbot.forward(60);
-karte: ..... | ..... | ..^..
-ziel: 0,1
-> Ein Feld nach vorn, dann schaut er nach links und fährt zwei Felder.
-
-runde:
-    mbot.turnRight();
-    mbot.turnRight();
-    mbot.forward(30);
-karte: ..... | ..^.. | .....
-ziel: 2,2
-> Zweimal rechts drehen heißt: Er schaut nach hinten. Dann fährt er ein Feld zurück, nach unten.
-
-runde:
-    mbot.forward(30);
-    mbot.turnRight();
-    mbot.forward(30);
-    mbot.turnRight();
-    mbot.forward(30);
-karte: .... | .... | .^..
-ziel: 2,2
-> Hoch, nach rechts, und nach der zweiten Drehung schaut er nach unten.
-:::
-
 ## Checkliste
 
 Schätze dich bei jedem Punkt ehrlich ein: ☂️ noch nicht, ⛅ teilweise, ☀️ kann ich sicher. Bei ⛅ und ☂️ hilft dir **Nachlesen**. Danach kommt der Wissenstest. Er zeigt dir, ob deine Einschätzung stimmt.

web/lessons/de/visubot/01-der-mbot2.md

@@ -285,6 +285,48 @@ tipp: Fünf Kästen `mbot.forward()` untereinander. Jeder fährt 10 cm.
 lösung: vb-gerade-loesung.visustruct
 :::
 
+## Spiel: Wo landet der mBot2?
+
+::: spiel fahrt
+titel: Spiel: Wo landet der mBot2?
+intro: Lies das Programm und tippe auf das Feld, auf dem der mBot2 am Ende steht. Danach fährt er die Strecke vor. Jedes Feld ist 30 cm groß. Vier Runden.
+frage: Auf welchem Feld steht der mBot2 am Ende?
+
+runde:
+    mbot.forward(60);
+    mbot.turnRight();
+    mbot.forward(30);
+karte: ..... | ..... | ..^..
+ziel: 3,0
+> Zwei Felder nach vorn, nach rechts drehen, ein Feld weiter.
+
+runde:
+    mbot.forward(30);
+    mbot.turnLeft();
+    mbot.forward(60);
+karte: ..... | ..... | ..^..
+ziel: 0,1
+> Ein Feld nach vorn, dann schaut er nach links und fährt zwei Felder.
+
+runde:
+    mbot.turnRight();
+    mbot.turnRight();
+    mbot.forward(30);
+karte: ..... | ..^.. | .....
+ziel: 2,2
+> Zweimal rechts drehen heißt: Er schaut nach hinten. Dann fährt er ein Feld zurück, nach unten.
+
+runde:
+    mbot.forward(30);
+    mbot.turnRight();
+    mbot.forward(30);
+    mbot.turnRight();
+    mbot.forward(30);
+karte: .... | .... | .^..
+ziel: 2,2
+> Hoch, nach rechts, und nach der zweiten Drehung schaut er nach unten.
+:::
+
 ## Den echten mBot2 verbinden
 
 ::: mbot2

web/lessons/en/09-bedingungen-verknuepfen.md

@@ -179,6 +179,7 @@ test: 2000 -> Leap year
 braucht: verzweigung
 tipp: Check the rule with examples first: 2024 is a leap year, 1900 is not, 2000 is. “Can be divided” means the remainder is 0.
 tipp: Divisible by 4 means `year % 4 == 0`, not divisible by 100 means `year % 100 != 0`. Join these two with `&&`, put brackets around them and add the case for 400 with `||`.
+tipp: Almost the solution: one single branch with the condition `(year % 4 == 0 && year % 100 != 0) || year % 400 == 0`. The true branch has `output: "Leap year"`, the false branch `output: "Not a leap year"`.
 lösung: l08-schaltjahr-loesung.visustruct
 :::
 

web/lessons/en/10-fallauswahl.md

@@ -76,6 +76,7 @@ test: 1, x, 2 -> Unknown operator
 braucht: fallauswahl
 tipp: First read in all three values. After that, a switch on the operator decides what is calculated.
 tipp: Before the switch, create `int result = 0`. In each case you calculate, for example, `result = a + b` and then output `result`. The case names are `"+"`, `"-"` and `"*"` in quotation marks, because the operator is a `String`.
+tipp: The outline from top to bottom: three inputs (`int a`, `String operator`, `int b`), then `int result = 0`, then a switch over `operator`. Case `"+"` holds `result = a + b` and `output: result`, cases `"-"` and `"*"` the same. The default case holds `output: "Unknown operator"`.
 lösung: l09-rechner-loesung.visustruct
 :::
 

web/lessons/en/12-do-while-schleife.md

@@ -80,6 +80,7 @@ test: 0 -> 0
 braucht: doUntilSchleife
 tipp: You need a variable for the sum that starts at 0 before the loop. In every pass the new number is added.
 tipp: Before the loop, create `int sum = 0` and `int number = 0`. In the loop you ask for `number` and calculate `sum = sum + number`. Adding the 0 does no harm. The loop keeps running as long as `number != 0`.
+tipp: The outline: `int sum = 0` and `int number = 0`, then a do-while loop with the condition `number != 0`. Inside it: the input of `number` and `sum = sum + number`. Below the loop: `output: sum`.
 lösung: l11-summe-loesung.visustruct
 :::
 

web/lessons/en/14-verschachteln.md

@@ -74,6 +74,7 @@ test: 2, 2 -> ## | ##
 braucht: forSchleife
 tipp: You need two loops inside each other: one for the lines and inside it one for the characters of a line.
 tipp: Build it like the triangle. The difference: the inner loop always counts up to `width`, not up to the line number. The outer loop counts up to `height`.
+tipp: The outline: inputs `width` and `height`. Outer for loop `int line = 1`, `line <= height`, `line++`. Inside it first `String text = ""`, then the inner for loop `int column = 1`, `column <= width`, `column++` with `text = text + "#"`, and below the inner loop `output: text`.
 lösung: l13-rechteck-loesung.visustruct
 :::
 

web/lessons/en/15-arrays.md

@@ -148,6 +148,7 @@ test: -5, -2, -9, -1, -3 -> Sum: -20 | Maximum: -1
 braucht: forSchleife, verzweigung
 tipp: Go through the array with a loop. Add every value to the sum and remember the largest value seen so far.
 tipp: Calculate the sum and the maximum in variables of their own and only output them at the end, e.g. with `output: "Sum: " + sum`. If your maximum starts at 0, the third test fails.
+tipp: The outline: create the array and read it in with a loop. Then `int sum = 0` and `int max = numbers[0]`. A second loop calculates `sum = sum + numbers[i]`, and a branch `numbers[i] > max` sets `max = numbers[i]` in its true branch. Finally the two outputs.
 lösung: l14-summe-max-loesung.visustruct
 :::
 

web/lessons/en/17-zeichenketten.md

@@ -145,6 +145,7 @@ test: a -> a
 braucht: forSchleife
 tipp: Go through the word character by character, but from back to front, and build a new text as you go.
 tipp: Create `String backwards = ""`. The loop starts at the last index `word.length() - 1` and counts down to 0 with `i--`. In every pass you add `word.charAt(i)` at the end.
+tipp: The outline: input `word`, then `String backwards = ""`. For loop with start `int i = word.length() - 1`, condition `i >= 0` and step `i--`. Inside it `backwards = backwards + word.charAt(i)`. Below the loop `output: backwards`.
 lösung: zk-rueckwaerts-loesung.visustruct
 :::
 
@@ -159,6 +160,7 @@ test: I like goats -> Words: 3
 braucht: anweisung
 tipp: There is always a space between the words. Which method splits a text at a character?
 tipp: Split the sentence into a String array with `sentence.split(" ")`. Its length is the number of words.
+tipp: The whole program has three boxes: the input `sentence`, then `String[] words = sentence.split(" ")` and finally `output: "Words: " + words.length`.
 lösung: zk-woerter-loesung.visustruct
 :::
 

web/lessons/en/19-suchen-und-sortieren.md

@@ -121,6 +121,7 @@ test: 2, 9, 2, 7, 6 -> 9 | 7 | 6 | 2 | 2
 braucht: forSchleife, verzweigung
 tipp: Look at the condition in the branch. It decides when two neighbours are swapped.
 tipp: You only need to change one single character. When should two neighbours be swapped if the larger card is supposed to go to the left?
+tipp: In the branch, change `cards[i] > cards[i + 1]` to `cards[i] < cards[i + 1]`. Then two neighbours swap when the bigger card is on the right, and the big card moves to the left.
 lösung: ss-absteigend-loesung.visustruct
 :::
 

web/lessons/en/visubot/00-struktogramm-und-editor.md

@@ -118,48 +118,6 @@ richtig: sequence
 > Two steps one after another, with no condition and no repetition.
 :::
 
-## Game: Where does the mBot2 end up?
-
-::: spiel fahrt
-titel: Game: Where does the mBot2 end up?
-intro: Read the program and tap the field where the mBot2 is at the end. Then it drives the route for you. Each field is 30 cm. Four rounds.
-frage: On which field is the mBot2 at the end?
-
-runde:
-    mbot.forward(60);
-    mbot.turnRight();
-    mbot.forward(30);
-karte: ..... | ..... | ..^..
-ziel: 3,0
-> Two fields forward, turn right, one more field.
-
-runde:
-    mbot.forward(30);
-    mbot.turnLeft();
-    mbot.forward(60);
-karte: ..... | ..... | ..^..
-ziel: 0,1
-> One field forward, then it faces left and drives two fields.
-
-runde:
-    mbot.turnRight();
-    mbot.turnRight();
-    mbot.forward(30);
-karte: ..... | ..^.. | .....
-ziel: 2,2
-> Turning right twice means it faces backwards. Then it drives one field down.
-
-runde:
-    mbot.forward(30);
-    mbot.turnRight();
-    mbot.forward(30);
-    mbot.turnRight();
-    mbot.forward(30);
-karte: .... | .... | .^..
-ziel: 2,2
-> Up, to the right, and after the second turn it faces down.
-:::
-
 ## Checklist
 
 Rate yourself honestly for each point: ☂️ not yet, ⛅ partly, ☀️ I can do this confidently. For ⛅ and ☂️, **Review** helps you. Then comes the quiz. It shows you whether your self-assessment is right.

web/lessons/en/visubot/01-der-mbot2.md

@@ -285,6 +285,48 @@ tipp: Five boxes `mbot.forward()` one below the other. Each drives 10 cm.
 lösung: vb-gerade-loesung.visustruct
 :::
 
+## Game: Where does the mBot2 end up?
+
+::: spiel fahrt
+titel: Game: Where does the mBot2 end up?
+intro: Read the program and tap the field where the mBot2 is at the end. Then it drives the route for you. Each field is 30 cm. Four rounds.
+frage: On which field is the mBot2 at the end?
+
+runde:
+    mbot.forward(60);
+    mbot.turnRight();
+    mbot.forward(30);
+karte: ..... | ..... | ..^..
+ziel: 3,0
+> Two fields forward, turn right, one more field.
+
+runde:
+    mbot.forward(30);
+    mbot.turnLeft();
+    mbot.forward(60);
+karte: ..... | ..... | ..^..
+ziel: 0,1
+> One field forward, then it faces left and drives two fields.
+
+runde:
+    mbot.turnRight();
+    mbot.turnRight();
+    mbot.forward(30);
+karte: ..... | ..^.. | .....
+ziel: 2,2
+> Turning right twice means it faces backwards. Then it drives one field down.
+
+runde:
+    mbot.forward(30);
+    mbot.turnRight();
+    mbot.forward(30);
+    mbot.turnRight();
+    mbot.forward(30);
+karte: .... | .... | .^..
+ziel: 2,2
+> Up, to the right, and after the second turn it faces down.
+:::
+
 ## Connecting the real mBot2
 
 ::: mbot2

web/lessons/pt/09-bedingungen-verknuepfen.md

@@ -179,6 +179,7 @@ test: 2000 -> Ano bissexto
 braucht: verzweigung
 tipp: Confirma primeiro a regra com exemplos: 2024 é bissexto, 1900 não é, 2000 é. “Divisível” quer dizer que o resto é 0.
 tipp: Divisível por 4 é `ano % 4 == 0`, não divisível por 100 é `ano % 100 != 0`. Junta estas duas com `&&`, põe parênteses à volta e acrescenta o caso do 400 com `||`.
+tipp: Quase a solução: uma única decisão com a condição `(ano % 4 == 0 && ano % 100 != 0) || ano % 400 == 0`. No ramo true fica `output: "Ano bissexto"`, no ramo false `output: "Não é ano bissexto"`.
 lösung: l08-schaltjahr-loesung.visustruct
 :::