planet: add handouts containing solutions

8 files changed, 115 insertions, 26 deletions

diff --git a/Info/9/3/Planet/algorithmik/for/variablen.md b/Info/9/3/Planet/algorithmik/for/variablen.md
index e8873813..30099161 100644
--- a/Info/9/3/Planet/algorithmik/for/variablen.md
+++ b/Info/9/3/Planet/algorithmik/for/variablen.md
@@ -9,14 +9,14 @@ Der Rover muss sich merken können wie viele Steine er bereits aufgehoben hat.
 :::
 
 Zum Speichern von Werten kann man Variablen verwenden.
-Eine Variable kann man sich wie eine [**Kiste**]{.solution} vorstellen, in der Werte abgelegt werden können.
-Jede Kiste hat einen eindeutigen [**Datentyp**]{.solution}.
+Eine Variable kann man sich wie eine [**Kiste**]{.gap} vorstellen, in der Werte abgelegt werden können.
+Jede Kiste hat einen eindeutigen [**Datentyp**]{.gap}.
 Das heißt, zum Speichern von Zahlen muss man andere Kisten (bzw. einen anderen Datentyp) verwenden als zum Speichern von Texten.
 
 :::{.tipp}
 Das Erzeugen einer Variable geschieht in zwei Schritten:
 
-##### 1. [Deklaration]{.solution}
+##### 1. [Deklaration]{.gap}
 
 Als erstes muss man den **Datentyp** und den **Namen** der Variable festlegen.
 
@@ -44,7 +44,7 @@ int zaehler;
 **Wichtig:** Der Datentyp wird nur einmal bei der "*Erstellung*" der Variable genannt, danach nie wieder!
 :::
 
-##### 2. [Initialisierung]{.solution}
+##### 2. [Initialisierung]{.gap}
 
 Nun muss man einen Anfangswert festlegen, den sogenannten **Initialwert**.
 
@@ -114,9 +114,6 @@ Erhöhe durch eine Zuweisung den Zähler um 1, wenn er auf einem Gestein steht:
 `zaehler = zaheler + 1`{.java}
 :::
 
-:::{.page-break}
-:::
-
 :::{.merke data-class="Merke: Variablen"}
 Eine Variable **speichert** einen Werte.
 
diff --git a/Info/9/3/Planet/algorithmik/if/bedingte-anweisung.md b/Info/9/3/Planet/algorithmik/if/bedingte-anweisung.md
index 594c86ce..cf0adf11 100644
--- a/Info/9/3/Planet/algorithmik/if/bedingte-anweisung.md
+++ b/Info/9/3/Planet/algorithmik/if/bedingte-anweisung.md
@@ -84,11 +84,29 @@ Mit dem Methodenaufruf `huegelVorhanden("vorne")` kannst du prüfen, ob vor dem
 ::::: {.column width=50%}
 **Programmcode:**  
 
-<div style="height: 7cm;"></div>
+::::::{.solution}
+<code style="white-space: pre;">
+if([huegelVorhanden("vorne")]{color="magenta"})<br>
+{<br>
+[drehe("rechts");]{style="color: orange; margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+[drehe("links");]{style="color: orange; margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+[drehe("links");]{style="color: orange; margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+[drehe("rechts");]{style="color: orange; margin-left: 20px;"}<br>
+}
+</code>
+::::::
 :::::
 
 ::::: {.column width=50%}
 **Struktogramm:**  
+
+:::::{.solution}
+![](umfahren-struktogramm.svg)
+:::::
 :::::
 ::::
 :::
@@ -216,11 +234,31 @@ Dann fahre am Hügel vorbei!
 ::::: {.column width=50%}
 **Programmcode:**  
 
-<div style="height: 10cm;"></div>
+::::::{.solution}
+<code style="white-space: pre;">
+if([huegelVorhanden("vorne")]{color="magenta"})<br>
+{<br>
+[drehe("rechts");]{style="color: orange; margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+[drehe("links");]{style="color: orange; margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+[drehe("links");]{style="color: orange; margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+[drehe("rechts");]{style="color: orange; margin-left: 20px;"}<br>
+} else {<br>
+[fahre();]{style="color: orange; margin-left: 20px;"}<br>
+}
+</code>
+::::::
 :::::
 
 ::::: {.column width=50%}
 **Struktogramm:**  
+
+::::::{.solution}
+![](umfahren-else-struktogramm.svg)
+::::::
 :::::
 ::::
 :::
diff --git a/Info/9/3/Planet/algorithmik/if/logik-operatoren.md b/Info/9/3/Planet/algorithmik/if/logik-operatoren.md
index dcd27400..253f99a3 100644
--- a/Info/9/3/Planet/algorithmik/if/logik-operatoren.md
+++ b/Info/9/3/Planet/algorithmik/if/logik-operatoren.md
@@ -9,18 +9,20 @@ Sammle mit dem Rover nur das Gestein ein, das die besonderen Bedingungen erfüll
 [_]{.blink}
 :::
 
-Mit logischen Operatoren können mehrere [Bedingungen]{.solution} miteinander verbunden werden.
+Mit logischen Operatoren können mehrere [Bedingungen]{.gap} miteinander verbunden werden.
 
 #### Der UND-Operator
 
 In Java kann man zwei Bedingungen mit einem **UND** verknüpfen, indem man den `&&`-Operator verwendet, z. B.
 
+:::{style="padding-left: 3rem;"}
 ```java
 if(huegelVorhanden("rechts") && huegelVorhanden("links"))
 {
     ...
 }
 ```
+:::
 
 Die Bedingung `huegelVorhanden("rechts") && huegelVorhanden("links")`{.java} ist nur dann wahr, wenn beide Bedingungen `huegelVorhanden("rechts")`{.java} und `huegelVorhanden("links")`{.java} gleichzeitig wahr sind.
 
@@ -45,13 +47,13 @@ Ergänze die Wahrheitstabelle:
 -------------------------------------------------------------------------------------------------------------------------------------
 `huegelVorhanden("rechts")`{.java}  `huegelVorhanden("links")`{.java}  `huegelVorhanden("rechts") && huegelVorhanden("links")`{.java}
 ----------------------------------  ---------------------------------  -------------------------------------------------------------- 
-  wahr                                wahr
+  wahr                                wahr                               [wahr]{.solution}
 
-  wahr                                falsch
+  wahr                                falsch                             [falsch]{.solution}
 
-  falsch                              wahr
+  falsch                              wahr                               [falsch]{.solution}
 
-  falsch                              falsch
+  falsch                              falsch                             [falsch]{.solution}
 -------------------------------------------------------------------------------------------------------------------------------------
 :::
 
@@ -67,7 +69,7 @@ Was bezweckt der `||`-Operator?
 #### Der ODER-Operator
 
 Analog zum **UND**-Operator `&&` gibt es in Java den **ODER**-Operator `||`.
-Dieser verknüpft zwei Bedingungen so miteinander, dass [mindestens eine]{.solution} wahr sein muss, damit die Gesamtaussage wahr ist.
+Dieser verknüpft zwei Bedingungen so miteinander, dass [mindestens eine]{.gap} wahr sein muss, damit die Gesamtaussage wahr ist.
 
 :::{.tipp}
 **Achtung**: Der **ODER**-Operator ist kein entweder/oder, d. h. auch beide Bedingungen können wahr sein.
@@ -94,13 +96,13 @@ Ergänze die Wahrheitstabelle:
 -------------------------------------------------------------------------------------------------------------------------------------
 `huegelVorhanden("rechts")`{.java}  `huegelVorhanden("links")`{.java}  `huegelVorhanden("rechts") || huegelVorhanden("links")`{.java}
 ----------------------------------  ---------------------------------  -------------------------------------------------------------- 
-  wahr                                wahr
+  wahr                                wahr                               [wahr]{.solution}
 
-  wahr                                falsch
+  wahr                                falsch                             [wahr]{.solution}
 
-  falsch                              wahr
+  falsch                              wahr                               [wahr]{.solution}
 
-  falsch                              falsch
+  falsch                              falsch                             [falsch]{.solution}
 -------------------------------------------------------------------------------------------------------------------------------------
 :::
 
@@ -114,9 +116,9 @@ Ergänze die Wahrheitstabelle:
 -----------------------------------------------------------------------
 `huegelVorhanden("rechts")`{.java}  `!huegelVorhanden("rechts")`{.java}  
 ----------------------------------  -----------------------------------
-  wahr
+  wahr                                [falsch]{.solution}
 
-  falsch
+  falsch                              [wahr]{.solution}
 -----------------------------------------------------------------------
 :::
 
@@ -159,6 +161,10 @@ Planet: Logische Operatoren
 ::::
 :::
 
+<!-- :::{.merke} -->
+<!-- TODO: Merke für die drei Operatoren. -->
+<!-- ::: -->
+
 :::{.erledigt}
 :::
 
diff --git a/Info/9/3/Planet/algorithmik/if/umfahren-else-struktogramm.tikz b/Info/9/3/Planet/algorithmik/if/umfahren-else-struktogramm.tikz
new file mode 100644
index 00000000..bae8867a
--- /dev/null
+++ b/Info/9/3/Planet/algorithmik/if/umfahren-else-struktogramm.tikz
@@ -0,0 +1,14 @@
+\begin{struktogramm}(70,30)
+  \ifthenelse[12]{1}{1}{\textcolor{magenta}{Hügel vorne}}{\hspace{-15mm}wahr}{\hspace{15mm}falsch}
+    \assign{\textcolor{orange}{rechts drehen}}
+    \assign{\textcolor{orange}{fahren}}
+    \assign{\textcolor{orange}{links drehen}}
+    \assign{\textcolor{orange}{fahren}}
+    \assign{\textcolor{orange}{fahren}}
+    \assign{\textcolor{orange}{links drehen}}
+    \assign{\textcolor{orange}{fahren}}
+    \assign{\textcolor{orange}{rechts drehen}}
+  \change
+    \assign{\textcolor{orange}{fahren}}
+  \ifend
+\end{struktogramm}
diff --git a/Info/9/3/Planet/algorithmik/if/umfahren-struktogramm.tikz b/Info/9/3/Planet/algorithmik/if/umfahren-struktogramm.tikz
new file mode 100644
index 00000000..92654d67
--- /dev/null
+++ b/Info/9/3/Planet/algorithmik/if/umfahren-struktogramm.tikz
@@ -0,0 +1,13 @@
+\begin{struktogramm}(70,30)
+  \ifthenelse[12]{1}{1}{\textcolor{magenta}{Hügel vorne}}{\hspace{-15mm}wahr}{\hspace{15mm}falsch}
+    \assign{\textcolor{orange}{rechts drehen}}
+    \assign{\textcolor{orange}{fahren}}
+    \assign{\textcolor{orange}{links drehen}}
+    \assign{\textcolor{orange}{fahren}}
+    \assign{\textcolor{orange}{fahren}}
+    \assign{\textcolor{orange}{links drehen}}
+    \assign{\textcolor{orange}{fahren}}
+    \assign{\textcolor{orange}{rechts drehen}}
+  \change
+  \ifend
+\end{struktogramm}
diff --git a/Info/9/3/Planet/algorithmik/while/bedingte-wiederholung.md b/Info/9/3/Planet/algorithmik/while/bedingte-wiederholung.md
index 6cc9026c..f142a63d 100644
--- a/Info/9/3/Planet/algorithmik/while/bedingte-wiederholung.md
+++ b/Info/9/3/Planet/algorithmik/while/bedingte-wiederholung.md
@@ -107,15 +107,33 @@ In Java kann das **kein** in "*kein Gestein*" durch ein Ausrufezeichen `!`{style
 ::::: {.column width=33%}
 **Programmcode:**  
 
-<div style="height: 10cm;"></div>
+::::::{.solution}
+<code style="white-space: pre;">
+void sucheStein() {<br>
+[while([!gesteinVorhanden()]{color="magenta"})]{style="margin-left: 20px;"}<br>
+[{]{style="margin-left: 20px;"}<br>
+[fahre();]{style="color: orange; margin-left: 40px;"}<br>
+[}]{style="margin-left: 20px;"}<br>
+[nimmGestein();]{style="margin-left: 20px;"}<br>
+}
+</code>
+::::::
 :::::
 
 ::::: {.column width=33%}
 **Programmablauf:**  
+
+::::::{.solution}
+![](sucheStein-flowchart.svg)
+::::::
 :::::
 
 ::::: {.column width=33%}
 **Struktogramm:**  
+
+::::::{.solution}
+![](sucheStein-struktogramm.svg)
+::::::
 :::::
 ::::
 :::
diff --git a/Info/9/3/Planet/algorithmik/while/sucheStein-flowchart.tikz b/Info/9/3/Planet/algorithmik/while/sucheStein-flowchart.tikz
index 393e85df..b46112fe 100644
--- a/Info/9/3/Planet/algorithmik/while/sucheStein-flowchart.tikz
+++ b/Info/9/3/Planet/algorithmik/while/sucheStein-flowchart.tikz
@@ -29,13 +29,15 @@
 \begin{tikzpicture}
   \node (start) {};
   \node[decision, below=of start] (decision1) {\textcolor{magenta}{Kein Gestein vorhanden}};
-  \node[process, below=of decision1] (process2) {\textcolor{orange}{fahre()}};
+
+  \node[process, below=of decision1] (process) {\textcolor{orange}{fahre()}};
+  \node[process, below=2cm of process] (process2) {nimmGestein()};
 
   % Arrows
   \draw[arrow] (start) -- (decision1);
-  \draw[arrow] (decision1) -- node[right] {Wahr} (process2);
+  \draw[arrow] (decision1) -- node[right] {Wahr} (process);
 
   % Decision branch
-  \draw[arrow] (decision1) -- node[above] {Falsch} ($(decision1.east) + (1cm, 0)$) -- ($(decision1.east) + (1cm, -3cm)$);
-  \draw[arrow] (process2.west) -| (-3, -2.4) |- (decision1.west);
+  \draw[arrow] (decision1) -- node[above] {Falsch} ($(decision1.east) + (1cm, 0)$) -- ($(decision1.east) + (1cm, -4cm)$) -- ($(decision1) + (0, -4cm)$) -- (process2);
+  \draw[arrow] (process.west) -| (-3, -2.4) |- (decision1.west);
 \end{tikzpicture}
diff --git a/Info/9/3/Planet/algorithmik/while/sucheStein-struktogramm.tikz b/Info/9/3/Planet/algorithmik/while/sucheStein-struktogramm.tikz
index 1ca2403a..1f2c2f4c 100644
--- a/Info/9/3/Planet/algorithmik/while/sucheStein-struktogramm.tikz
+++ b/Info/9/3/Planet/algorithmik/while/sucheStein-struktogramm.tikz
@@ -2,4 +2,5 @@
   \while{solange \textcolor{magenta}{kein Gestein vorhanden}}
     \assign{\textcolor{orange}{fahre()}}
   \whileend
+  \assign{nimmGestein()}
 \end{struktogramm}