gf_informatik:karatutorial:logik

Inhaltsverzeichnis

Booleans & Logik

Booleans & Logik

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

while not kara.treeFront():
    kara.move()

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 sein Gegenteil.

	`kara.treeFront()`	`not kara.treeFront()`
	`True`	`False`
	`False`	`True`

Tab. 1: Wahrheitstabelle für die Negation (not)

In der Informatik nennen wir einen Wahrheitswert auch Boolean. Das Wissenschaftsgebiet der 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:

TTTTTTTTTTTT T T T > L L T T TT T T T T TTTTTTTTTTTT while not kara.treeFront(): if not kara.onLeaf() and kara.treeRight(): kara.putLeaf() kara.move() assert world_leaves() == 4, "Vier Blätter erwartet"

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 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.

`and`		`kara.treeRight()`
`and`		`True`	`False`
`kara.treeLeft()`	`True`	`True`	`False`
`kara.treeLeft()`	`False`	`False`	`False`

Tab. 2: Wahrheitstabelle für die Konjunktion (and)

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 ein Baum steht
  - legt sie ein Blatt
- dann geht sie einen Schritt

Wie lang ist der Tunnel?

TTTTTTTTTTTT T T T TTTTTT T > T T TT TTT T T T TTTTTTTTTTTT

while not kara.treeFront(): if kara.treeLeft() and kara.treeRight(): kara.putLeaf() kara.move()

assert world_leaves() == 3

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 Disjunktion.

`or`		`kara.treeRight()`
`or`		`True`	`False`
`kara.treeLeft()`	`True`	`True`	`True`
`kara.treeLeft()`	`False`	`True`	`False`

Tab. 3: Wahrheitstabelle für die Disjunktion (or)

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.

TTTTTTTTTTTT T T T TTTTTT T >LLLLLLL T T TT TTT T T T TTTTTTTTTTTT

while not kara.treeFront(): if kara.treeLeft() or kara.treeRight(): kara.removeLeaf() kara.move()

assert world_leaves() == 1

Aufgabe D3: Logisch

Betrachte folgenden Code und Karas Welt! Auf welchem Feld wird Kara am Ende des Programms sein?

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()

Lösung

Präzedenz (Operatorrangfolge)

In der Mathematik gilt Punkt-vor-Strich - bei Boolean-Verknüpfungen gilt ebenfalls eine Rangfolge:

Negation (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:

(kara.onLeaf() and (not kara.treeLeft())) or kara.mushroomFront()

TTTTTTTTTTTT T T T M T T L T T T T T > L T T T T T TTTTTTTTTTTT while not kara.treeFront(): if kara.onLeaf() and not kara.treeLeft() or kara.mushroomFront(): kara.turnLeft() kara.move()

Aufgabe D4: Blätter um die Bäume

Schreibe Python-Code, wie folgt - verwende Klammern wo nötig, um die Operatorreihenfolge zu kontrollieren.

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

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

while not kara.mushroomFront(): if (kara.treeLeft() or kara.treeRight()) and not kara.onLeaf(): kara.putLeaf() if kara.treeFront(): kara.turnRight() else: kara.move()

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