## Booleans & Logik

Wir haben bereits gesehen, wie wir mit dem Schlüsselwort `not` eine Aussage in ihr Gegenteil verkehren können:

<code python>
while not kara.treeFront():
    kara.move()
</code>

Die Funktion `kara.treeFront()` gibt einen _Wahrheitswert_ zurück: Entweder wahr oder falsch, in Python `True` oder `False`. Kara soll solange weiterlaufen, als _kein_ Baum vor ihr steht. Mit `not` verwandeln wir den Wert von `treeFront()` in ihr Gegenteil.

In der Informatik nennen wir einen Wahrheitswert auch [[wpde>Boolean]]. Das Wissenschaftsgebiet der [[wpde>Aussagenlogik]] beschäftigt sich mit der Verknüpfung von mehreren Booleans zu einem neuen Wert.

### Konjunktion (Und-Verknüpfung)
Betrachte folgendes Beispiel: Kara soll immer dann ein neues Blatt legen, wenn noch keins vorhanden ist **und** rechts von ihr ein Baum steht:

<kara-exercise step="300" id="bool_and">
<kara-world>
   TTTTTTTTTTTT
   T          T
   T > L  L   T
   T   TT  T  T
   T          T
   TTTTTTTTTTTT
</kara-world>
while not kara.treeFront():
    if not kara.onLeaf() and kara.treeRight():
        kara.putLeaf()
    kara.move()
<kara-tests>
assert world_leaves() == 4, "Vier Blätter erwartet"
</kara-tests>
</kara-exercise>

**Merke**:
  * mit dem Schlüsselwort `and` können zwei Booleans verknüpft werden. Das Resultat ist nur dann `True`, wenn beide Operanden `True` sind, sonst `False`.
  * Eine Und-Verknüpfung heisst **[[wpde>Konjunktion_(Logik)|Konjunktion]]**.
  * mit `kara.treeRight()` und `kara.treeLeft()` können wir Bäume neben Kara feststellen.
  * `not` bindet enger als `and`: das `not kara.onLeaf()` negiert nur die Blatt-Bedingung, nicht den ganzen `and`-Ausdruck.

#### Aufgabe D1: Tunnel markieren
Hilf Kara, den Tunnel zu markieren. Schreibe Python-Code wie folgt:

  * Kara wiederholt folgende Schritte, solange sie nicht vor einem Baum steht:
    * wenn links _und_ rechts einen Baum sieht
      * legt sie ein Blatt
    * dann geht sie einen Schritt

Wie lang ist der Tunnel?

<kara-exercise id="tunnel1" hidesolution>
<kara-world>
   TTTTTTTTTTTT
   T          T
   T     TTTTTT
   T >        T
   T   TT TTT T
   T          T
   TTTTTTTTTTTT
</kara-world>
<kara-solution>
while not kara.treeFront():
    if kara.treeLeft() and kara.treeRight():
        kara.putLeaf()
    kara.move()
</kara-solution>
<kara-tests>
assert world_leaves() == 3
</kara-tests>
</kara-exercise>
### Disjunktion (Oder-Verknüpfung)

Wir können auch zwei Booleans so verknüpfen, dass das Resultat `True` ist, wenn mindestens einer der beiden `True` ist. Das Schlüsselwort dazu heiss `or` (oder), die Operation heisst **[[wpde>Disjunktion]]**.

#### Aufgabe D2: Tunnelräumung
Schreibe Code, der immer dann ein Blatt entfernt, wenn links oder rechts von Kara ein Baum steht. Stoppe, wenn du einen Baum vor dir hast.

<kara-exercise id="tunnel2" hidesolution>
<kara-world>
   TTTTTTTTTTTT
   T          T
   T     TTTTTT
   T >LLLLLLL T
   T   TT TTT T
   T          T
   TTTTTTTTTTTT
</kara-world>
<kara-solution>
while not kara.treeFront():
    if kara.treeLeft() or kara.treeRight():
        kara.removeLeaf()
    kara.move()
</kara-solution>
<kara-tests>
assert world_leaves() == 1
</kara-tests>
</kara-exercise>
### Präzedenz (Operatorrangfolge)
In der Mathematik gilt [[wpde>Punktrechnung_vor_Strichrechnung|Punkt-vor-Strich]] - bei Boolean-Verknüpfungen gilt ebenfalls eine Rangfolge:
  - Negierung (`not`)
  - Konjunktion (`and`)
  - Disjunktion (`or`)

Im Beispiel unten:
  * beim ersten Blatt dreht Kara links (die erste Hälfte der Disjunktion ist wahr: beide Bedingungen `kara.onLeaf() and not kara.treeLeft()` sind wahr).
  * beim Pilz dreht Kara ebenso links (die zweite Hälftet der Disjunktion ist wahr: `kara.mushroomFront()`).
  * beim zweiten Blatt dreht Kara *nicht*:
    * `kara.mushroomFront()` ist falsch
    * `kara.onLeaf()` ist wahr, aber
    * `not kara.treeLeft()` ist falsch, damit ist die Konjunktion falsch, damit ist auch die Disjunktion falsch.

Mit Klammern verdeutlicht:
<code python>(kara.onLeaf() and (not kara.treeLeft())) or kara.mushroomFront()</code>

<kara-exercise id="precedence" hidesolution>
<kara-world>
   TTTTTTTTTTTT
   T          T
   T    M     T
   T  L       T
   T  T       T
   T >  L     T
   T          T
   T          T
   TTTTTTTTTTTT
</kara-world>
while not kara.treeFront():
    if kara.onLeaf() and not kara.treeLeft() or kara.mushroomFront():
        kara.turnLeft()
    kara.move()
</kara-exercise>


#### Aufgabe D3: Logisch
Betrachte folgenden Code und Karas Welt! Auf welchem Feld wird Kara am Ende des Programms sein?

<WRAP group>
<WRAP column twothirds>
<code python>
while not kara.treeFront():
    if kara.onLeaf() and kara.treeRight():
        kara.turnLeft()
    if kara.onLeaf() and kara.mushroomFront():
        kara.turnLeft()
        kara.turnLeft()
    if kara.mushroomFront() or kara.treeLeft():
        kara.turnRight()
    kara.move()
</code>
</WRAP>
<WRAP column third>
{{.:aufgaben:pasted:20260828-121925.png?nolink&400}}
</WRAP>
</WRAP>

<nodisp 2>
++++Lösung|

Kara landet auf `J4`.

<kara-exercise id="boolean_walk">
<kara-world>
   TTTTTTTTTTT
   T   M   L T
   TM  L     T
   T  M  L LTT
   T    M    T
   T         T
   TL   L    T
   T     T L T
   T       TTT
   T  >   L  T
   TTTTTTTTTTT
</kara-world>
while not kara.treeFront():
    if kara.onLeaf() and kara.treeRight():
        kara.turnLeft()
    if kara.onLeaf() and kara.mushroomFront():
        kara.turnLeft()
        kara.turnLeft()
    if kara.mushroomFront() or kara.treeLeft():
        kara.turnRight()
    kara.move()
</kara-exercise>
++++
</nodisp>

#### Aufgabe D4: Blätter um die Bäume
Schreibe Python-Code, wie folgt:
  * Kara macht die folgenden Schritte, solange kein Pilz vor ihr steht:
    * wenn links oder rechts ein Baum steht und kein Blatt vorhanden ist:
      * dann legt sie eins hin.
    * wenn ein Baum vor ihr ist,
      * so wendet dreht sie einmal nach rechts.
      * andernfalls: geht sie einen Schritt weiter

<kara-exercise id="planter" step="100" hidesolution>
<kara-world>
   TTTTTTTTTTT
   T M TTT  TT
   T >   LL  T
   T T  TTT  T
   TT TTT   LT
   TT        T
   TT  MT   TT
   T    LL   T
   TTT    T  T
   T  M      T
   TTTTTTTTTTT
</kara-world>
<kara-solution>
while not kara.mushroomFront():
    if (kara.treeLeft() or kara.treeRight()) and not kara.onLeaf():
        kara.putLeaf()
    if kara.treeFront():
        kara.turnRight()
    else:
        kara.move()
</kara-solution>
<kara-tests>
<kara-world>
   TTTTTTTTTTT
   T M TTT  TT
   T L LLLL LT
   T T  TTT LT
   TTLTTT   LT
   TTLLLL   LT
   TTL MT   TT
   TLL  LLL LT
   TTT    T LT
   T  M LLLLLT
   TTTTTTTTTTT
</kara-world>
</kara-tests>
</kara-exercise>