Algorithmen und ihre Eigenschaften

1
Algorithmen und ihre Eigenschaften

• Klaus Becker
• 2012

2
Algorithmen und ihre Eigenschaften
3
Teil 1
Algorithmen - früher und heute Fallstudie -
Ägyptische Multiplikation
4
Fallstudie - Ägyptische Multiplikation
Algorithmen werden seit den Anfängen der
Mathematik beim Rechnen benutzt. Im "Papyrus
Rhind" wird beschrieben, wie in Ägypten Zahlen
multipliziert wurden.
Im Jahre 1858 kaufte der englische Archäologe
A.H. Rhind in Luxor ein aus zwei Stücken
bestehendes Papyrus. Erst einige Jahrzehnte
später stellte sich heraus, dass das dritte,
fehlende Mittelstück sich in einem New Yorker
Museum befand. Zusammen hat das Dokument eine
Länge von 5,25 m und eine Breite von 33 cm. Es
wurde rund 1700 Jahre vor Christi Geburt
geschrieben und enthält viele Mathematikaufgaben.
Heute heißt dieses Schriftstück Papyrus
Rhind. siehe http//buergernetz.muens
ter.de/mauritz//matheserver/teller/aegypten/zahl2.
html
5
Fallstudie - Ägyptische Multiplikation
Aufgaben (a) Versuche, anhand der Beispiele zu
erschließen, wie Zahlen im alten Ägypten
dargestellt wurden. (b) Welche Gemeinsamkeiten
und welche Unterschiede gibt es zu unserer
Zahldarstellung heute? (c) Hieroglyphenzahlen
lassen sich gut schriftlich addieren und
subtrahieren. Beschreibe, wie man dabei vorgehen
kann. (d) Warum kann man unsere schriftliche
Multiplikation nicht mit Hieroglyphenzahlen
nachbilden? (e) Recht gut funktioniert das
Verdoppeln und Halbieren von Hieroglyphenzahlen.
Probiere das selbst aus.
6
Fallstudie - Ägyptische Multiplikation
Aufgaben Finde heraus, wie die ägyptische
Multiplikation funktioniert. Berechne mit dem
Verfahren die folgenden Produkte 15 14 9
120 16 7 Überprüfe aber auch, ob die
erzielten Ergebnisse stimmen.
7
Fallstudie - Ägyptische Multiplikation

• Man schreibt die beiden zu multiplizierenden
  Zahlen nebeneinander.
• Auf der linken Seite werden die Zahlen jeweils
  halbiert (Reste abgerundet) und die Ergebnisse
  untereinander geschrieben, bis man zur 1 gelangt.
  
• Auf der rechten Seite werden die Zahlen
  verdoppelt und untereinander geschrieben.
• Die rechts stehenden (verdoppelten) Zahlen werden
  gestrichen, wenn die links stehende Zahl gerade
  ist.
• Die Summe der nicht gestrichenen rechts stehenden
  Zahlen ergibt das gesuchte Produkt.

umgangssprachliche Beschreibung
8
Fallstudie - Ägyptische Multiplikation
Trace / Ablaufprotokoll
Bedingung Anweisung z1 z2 p
13 12
p 0 0z1 gt 0
(w)z1 ungerade (w) p p z2
12 z1 z1 // 2
6 z2 z2 2 24z1 gt 0
(w)z1 ungerade (f) z1
z1 // 2 3 z2 z2 2
48 z1 gt 0 (w)z1 ungerade (w)
p p z2 60
z1 z1 // 2 1 z2 z2
2 96z1 gt 0 (w)z1 ungerade (w)
p p z2 156
z1 z1 // 2 0 z2
z2 2 192z1 gt 0 (f)
Algorithmus in Struktogrammform
9
Fallstudie - Ägyptische Multiplikation
Aufgaben Entwickle ein Python-Programm zum
Algorithmus. Teste das Programm mit verschiedenen
Eingaben.
10
Fallstudie - Ägyptische Multiplikation
Bedingung Anweisung z1 z2 p
13 12
p 0 0z1 gt 0
(w)z1 ungerade (w) p p z2
12 z1 z1 // 2
6 z2 z2 2 24z1 gt 0
(w)z1 ungerade (f) z1
z1 // 2 3 z2 z2 2
48 z1 gt 0 (w)z1 ungerade (w)
p p z2 60
z1 z1 // 2 1 z2 z2
2 96z1 gt 0 (w)z1 ungerade (w)
p p z2 156
z1 z1 // 2 0 z2
z2 2 192z1 gt 0 (f)
13 621 (320)21
((121)20)21 (((021)21)20)21
02222 1222 122 02 1 13 12
(123 122 021 120) 12 812
412 0 112 96 48 12 156
13
12
?
6
24
3
48
?
Aufgabe Erkläre, warum der Algorithmus das
Multiplikationsverfahren korrekt beschreibt.
1
96
?
156
11
Fallstudie - Ägyptische Multiplikation
Obwohl das Multiplikationsverfahren der Ägypter
heute kaum noch benutzt wird, hat der Algorithmus
und die dahinter steckende Idee nichts an ihrer
Bedeutung verloren. Die Idee wird heute beim
"schnellen Potenzieren" benutzt. Aufgabe In der
freien Enzyklopädie Wikipedia findet man unter
dem Stichwort "schnelles Potenzieren" die
folgende Verfahrensbeschreibung "Der Exponent
wird schrittweise halbiert (das Ergebnis wird
abgerundet) und die Basis schrittweise quadriert.
Man streicht die Zeilen mit geradem Exponenten.
Das Produkt der nichtgestrichenen rechten Zahlen
ist die gesuchte Potenz." Teste erst einmal
dieses Verfahren zum schnellen Potenzieren.
Entwickle anschließend ein Struktogramm zur
Beschreibung des Verfahrens. Du kannst dich am
Algorithmus zur ägyptischen Multiplikation
orientieren.
12
Fallstudie - Ägyptische Multiplikation
Das Rechnen mit Zahlen ist eine bedeutende
Kulturleistung der Menschheit, die gewaltige
Auswirkungen hat. Viele Bereiche unseres Lebens
wären kaum noch oder gar nicht denkbar, wenn sie
nicht von Zahlen und Berechnungen mit diesen
Zahlen begleitet wären. Schon sehr früh hat man
versucht, das Rechnen mit Zahlen zu
automatisieren. So sind z.B. unsere Verfahren zum
schriftlichen Rechnen Verfahren, die man
schematisch durchführen kann, ohne sie im
geringsten Maße verstanden zu haben. Diese Form
der Automatisierung ermöglicht es, sehr viele
Berechnungen ohne Nachdenken schnell
auszuführen. Algorithmen wurden also schon
entwickelt und benutzt, lange bevor es Computer
gab. Zu diesen algorithmischen Verfahren gehört
auch das von den Ägyptern benutzte Verfahren zur
Multiplikation von Zahlen. Ohne algorithmische
Rechenverfahren wäre es den Ägyptern wohl kaum
möglich gewesen, eine funktionierende
Gesellschaft aufzubauen, die sogar in der Lage
war, riesige Pyramiden zu bauen.
13
Teil 2
Algorithmen - früher und heute Fallstudie -
PageRank
14
Fallstudie - PageRank
Wenn man im Internet nach Information sucht, dann
benutzt man sehr häufig eine Suchmaschine. Hier
gibt man den Suchbegriff ein - es können
natürlich auch mehrere sein, die Suchmaschine
liefert dann die Adressen von Webseiten zu diesem
Suchbegriff. Die hier benutzte Suchmaschine
Ixquick hat (ungefähr) 2877 Suchergebnisse
gefunden. Die ersten 10 dieser Suchergebnisse
werden in Kurzform angezeigt. Beachte, dass es
weit mehr als 2877 Webseiten gibt, auf denen der
Begriff "Algorithmus" vorkommt. So liefert die
Suchmaschine Google derzeit (ungefähr) 2.640.000
Suchergebnisse zu diesem Suchbegriff. Die
Suchmaschine Ixquick liefert also nur eine
Auswahl von Webseiten zum eingegebenen
Suchbegriff. Hier ergibt sich das Problem, nach
welchen Kriterien Ixquick die relevanten
Webseiten auswählt. Ein weiteres Problem ergibt
sich bei der Präsentation der Suchergebnisse. Wie
sollen die Kurzbeschreibungen zu den 2877
gefundenen Webseiten angeordnet werden? Für den
Benutzer wäre es hilfreich, wenn wichtige Seiten
zuerst aufgelistet würden.
15
Fallstudie - PageRank
Die gesamte "Welt der verlinkten Webseiten"
besteht aus sehr vielen Webseiten. Zur Lösung des
Ranking-Problems muss man (zum Glück) nicht diese
Gesamtheit betrachten. Es reicht, wenn man das
Ranking-Problem für eine "kleine Welt" vernetzter
Webseiten löst - im großen funktioniert es dann
genauso.
Aufgabe Schaue dir die Webseitenwelt in der
Darstellung genauer an. Welche der dort gezeigten
Webseiten würdest du (ohne Berücksichtigung der
Seiteninhalte) eine größere / geringere Relevanz
einräumen? Woran orientierst du dich bei der
Einschätzung der Relevanz?
16
Fallstudie - PageRank
Modellierung des Surfverhaltens (A1) Zu Beginn
verteilen sich alle Besucher gleichmäßig auf die
Webseiten. (A2) Alle Besucher folgen jeweils im
gleichen Takt einem Link auf eine weitere
Webseite. Wenn auf einer Webseite mehrere Links
vorkommen, dann verteilen sich die Besucher
gleichmäßig auf die verschiedenen Links. (A3)
Besucher, die in eine Sackgasse geraten (d.h.
Webseiten besuchen, die keine Links auf weitere
Seiten enthalten), besuchen im nächsten Schritt
irgend eine der gegebenen Webseiten. Sie teilen
sich dabei gleichmäßig auf alle zur Verfügung
stehenden Webseiten auf.
Aufgabe Wie viele Nutzer besuchen unter den
veränderten Annahmen nach einem Takt die
verschiedenen Webseiten?
17
Fallstudie - PageRank
Modellierung des Surfverhaltens (A1) Zu Beginn
verteilen sich alle Besucher gleichmäßig auf die
Webseiten. (A2) Alle Besucher folgen jeweils im
gleichen Takt einem Link auf eine weitere
Webseite. Wenn auf einer Webseite mehrere Links
vorkommen, dann verteilen sich die Besucher
gleichmäßig auf die verschiedenen Links. (A3)
Besucher, die in eine Sackgasse geraten (d.h.
Webseiten besuchen, die keine Links auf weitere
Seiten enthalten), besuchen im nächsten Schritt
irgend eine der gegebenen Webseiten. Sie teilen
sich dabei gleichmäßig auf alle zur Verfügung
stehenden Webseiten auf. (A4) Ein bestimmter
Prozentsatz der Nutzer (z.B. 20) springt in
jedem Takt zu einer beliebigen anderen Webseite.
Sie teilen sich dabei gleichmäßig auf alle zur
Verfügung stehenden Webseiten auf.
Aufgabe Erkläre, wie die in der Abbildung
gezeigten Zahlen gemäß Annahmen zustande kommen
18
Fallstudie - PageRank
Aufgaben (a) Führe die Berechnungen für mehrere
Takte durch. Benutze (gerundete) Dezimalzahlen,
wenn die Divisionen nicht aufgehen - auch, wenn
das der Wirklichkeit nicht mehr entspricht. (b)
Beschreibe die Berechnungen mit einem Algorithmus.
19
Fallstudie - PageRank
Simulation des Surfverhaltens Surf- und
Sprunganteile p 0.8 q 1-p Initialisierung a
300 b 300 c 300 d 300 e 300 f 300
Ausgabe ...
Aufgabe Implementiere und teste den
PageRank-Verfahren.
... wiederholte Berechnung der
Besucherzahlen for i in range(10)
Bestimmung der neuen Besucherzahlen nach einen
Takt a1 (pc)/3 q(abcdef)/6
(pf)/6 b1 (pa)/2 pe
q(abcdef)/6 (pf)/6 c1 (pa)/2
(pb)/2 pd q(abcdef)/6 (pf)/6 d1
(pc)/3 (pb)/2 q(abcdef)/6
(pf)/6 e1 (p0) q(abcdef)/6
(pf)/6 f1 (pc)/3 q(abcdef)/6
(pf)/6 a a1 b b1 c c1 d
d1 e e1 f f1 Ausgabe ...
20
Fallstudie - PageRank
Simulation des Surfverhaltens Surf- und
Sprunganteile p 0.8 q 1-p Initialisierung n
1000 a n/6 b n/6 c n/6 d n/6 e n/6 f
n/6 Ausgabe ...
Aufgabe Die Suchmaschine Google benutzt - in
einer Grundversion - das folgende
Simulationsprogramm.
... wiederholte Berechnung der
Besucherzahlen for i in range(10)
Bestimmung der neuen Besucherzahlen nach einen
Takt a1 (pc)/3 (qn)/6
b1 (pa)/2 pe (qn)/6 c1
(pa)/2 (pb)/2 pd (qn)/6 d1
(pc)/3 (pb)/2 (qn)/6 e1 (p0)
(qn)/6 f1 (pc)/3
(qn)/6 a a1 b b1
c c1 d d1 e e1 f f1
Ausgabe ...
Vergleiche die hier benutzte Modellierung des
Surfverhaltens mit der oben entwickelten
Modellierung.
21
Fallstudie - PageRank
Viele Menschen nutzen das Internet (genauer
WWW), wenn sie Information über ein bestimmtes
Thema suchen. Meist geben sie ein oder mehrere
Stichwörter in eine Suchmaschine ein - und schon
kann es mit der Informationsaufnahme losgehen.
Suchmaschinen finden oft eine riesige Anzahl von
Webseiten, die die eingegebenen Suchbegriffe
enthalten. Suchmaschinen nutzen dann eingebaute
Strategien, um diese Webseiten dem Nutzer zu
präsentieren. Mit Hilfe vorgegebener Algorithmen
- zu denen auch das hier entwickelte Verfahren
gehört - werden die Webseiten mit Rankingzahlen
bewertet und dann entsprechend dieser
Rankingwerte nach ihrer Relevanz sortiert
angezeigt. Das ist sicher sinnvoll, hat aber auch
Konsequenzen. Viele Nutzer schauen sich die
ersten Suchergebnisse genauer an, die weiteren -
so glaubt man - werden wohl nicht viel Neues
bringen. Das hat zur Folge, dass viele Nutzer nur
das finden, was von eingebauten
Ranking-Algorithmen für besonders relevant
befunden wurde. Ranking-Algorithmen steuern auf
diese Weise die Informationsaufnahme der Nutzer.
22
Fallstudie - PageRank
"Die perfekte Suchmaschine versteht genau das,
was man meint, und liefert genau das, wonach man
sucht. Das war die Vision von Larry Page, als er
Google im Jahre 1998 mitgründete. Seither
arbeiten die Kalifornier daran, diesem Ziel näher
zu kommen. Vor drei Jahren ist ihnen ein großer
Schritt gelungen. Tippten bis dahin zwei Nutzer
die gleichen Wörter in Googles Suchmaske, bekamen
diese dieselbe Antwort. Heute bekommt jeder
Suchende eine individuell auf ihn zugeschnittene
Reaktion des Computers. Doch so beginnt sich die
Welt des Suchenden auf die beschauliche Sammlung
seiner Vorlieben zu verengen. Aus dem Tor ins
World Wide Web wird ein Tor, das letztlich zu ihm
selbst zurückführt. In seinem Buch Filter Bubble
kritisiert der Netzpublizist Eli Pariser, dass
man sich im Internet in vorgefilterten Blasen
bewege Mehr und mehr wird dein Computermonitor
zum Spiegel, der deine eigenen Interessen
reflektiert, während algorithmische Aufseher
beobachten, was du anklickst!" Quelle
http//www.zeit.de/2012/32/Zensur-Google-Internets
uche
23
Teil 3
Algorithmen - früher und heute Fallstudie -
Turnierplanung
24
Fallstudie - Turnierplanung
Zum alljährlichen Schulschachturnier haben sich
angemeldet Alina, Betül, Chris, Dominik,
Elisabeth und Florian. Gespielt wird wie jedes
Jahr - jeder gegen jeden. Jedes Spiel dauert
maximal 15 Minuten.
Runde 1 AF, BD, CE Runde 2 AE, BF,
CD Runde 3 AD, BE, CF ...
Aufgaben (a) Ein Turnierplan muss her. Kannst du
den gezeigten Turnierplan fortsetzen? Welche
Schwierigkeit tritt hier auf? (b) Schaffst du
es, einen Turnierplan zu entwickeln, der mit 5
Spielrunden auskommt? Tipp Bei der Entwicklung
eines Turnierplans verliert man leicht den
Überblick, wer bereits gegen wen gespielt hat.
Hier hilft es, wenn man sich die Spielpaarungen
veranschaulicht, z.B. so Die Spielpaarungen der
1. Runde werden mit roten Verbindungslinien
markiert, die der 2. Runde mit gelben, die der 3.
Runde mit grünen usw..
25
Fallstudie - Turnierplanung
Kurz vor dem Turnier fragen Georg und Hannah, ob
sie nicht auch noch mitspielen können. Der
gesamte Turnierplan muss jetzt schnell
umgestrickt werden. Schaffst du das?
Runde 1 HA, GB, FC, ED Runde 2 HB, AC,
GD, FE Runde 3 HC, ... ...
Aufgaben (a) Ergänze den dargestellten
Turnierplan. (b) Erkennst du hier bereits ein
"Planungsmuster"?
26
Fallstudie - Turnierplanung
Ordne A, B, ..., G zu einem 7-Eck an. Setze H in
die Mitte des 7-Ecks. Runde 1 Verbinde H mit
A. Verbinde die Ecken des 7-Ecks, die von A aus
in 1 Schritt erreichbar sind. Verbinde die Ecken
des 7-Ecks, die von A aus in 2 Schritten
erreichbar sind. Verbinde die Ecken des 7-Ecks,
die von A aus in 3 Schritten erreichbar sind.
Runde 2 Verbinde H mit B. Verbinde die Ecken des
7-Ecks, die von B aus in 1 Schritt erreichbar
sind. Verbinde die Ecken des 7-Ecks, die von B
aus in 2 Schritten erreichbar sind. Verbinde die
Ecken des 7-Ecks, die von B aus in 3 Schritten
erreichbar sind. Runde 3 Verbinde H mit
C. Verbinde die Ecken des 7-Ecks, die von C aus
in 1 Schritt erreichbar sind. Verbinde die Ecken
des 7-Ecks, die von C aus in 2 Schritten
erreichbar sind. Verbinde die Ecken des 7-Ecks,
die von C aus in 3 Schritten erreichbar sind. usw.
Aufgabe Überprüfe zunächst die vorgegebene
Beschreibung. Wie muss sie fortgesetzt werden, um
Runde 4 zu erhalten?
27
Fallstudie - Turnierplanung
Erzeugung eines Turnierplans mit n
Teilnehmern Ordne die Teilnehmer 0, 1, ..., (n-2)
zu einem (n-1)-Eck an. Setze den Teilnehmer n-1
in die Mitte des (n-1)-Ecks. Runde 1 Verbinde
n-1 mit 0. Verbinde die Ecken des (n-1)-Ecks, die
von 0 aus in 1 Schritt erreichbar sind. Verbinde
die Ecken des (n-1)-Ecks, die von 0 aus in 2
Schritten erreichbar sind. ... Verbinde die Ecken
des (n-1)-Ecks, die von 0 aus in n/2-1 Schritten
erreichbar sind. Runde 2 Verbinde n-1 mit
1. Verbinde die Ecken des (n-1)-Ecks, die von 1
aus in 1 Schritt erreichbar sind. Verbinde die
Ecken des (n-1)-Ecks, die von 1 aus in 2
Schritten erreichbar sind. ... Verbinde die Ecken
des (n-1)-Ecks, die von 1 aus in n/2-1 Schritten
erreichbar sind. Runde 3 Verbinde n-1 mit
2. Verbinde die Ecken des (n-1)-Ecks, die von 2
aus in 1 Schritt erreichbar sind. Verbinde die
Ecken des (n-1)-Ecks, die von 2 aus in 2
Schritten erreichbar sind. ... Verbinde die Ecken
des (n-1)-Ecks, die von 2 aus in n/2-1 Schritten
erreichbar sind. ... ...
28
Fallstudie - Turnierplanung
Runde 1 7 0-17 0-27 0-37
0 01 02 03 Runde 2 7
1-1 1-27 1-37 1
11 12 13 Runde 3 7 2-1 2-2
2-37 2 21 22
23 Runde 4 Runde 5 Runde 6 7 5-1
5-2 5-3 5 51
52-7 53-7 Runde 7
Aufgabe Analysiere das Verfahren. Welche Muster
kannst du erkennen? Ergänze die noch fehlenden
Runden.
29
Fallstudie - Turnierplanung
Runde 1 7 0-17 0-27 0-37
0 01 02 03 Runde 2 7
1-1 1-27 1-37 1
11 12 13 Runde 3 7 2-1 2-2
2-37 2 21 22
23 Runde 4 Runde 5 Runde 6 7 5-1
5-2 5-3 5 51
52-7 53-7 Runde 7
Erzeugung eines Turnierplans mit 8
Teilnehmern Für i von 0 bis 6 Runde i1
Ausgabe des Spielpaars 7i Für j von 1 bis
3 Setze a auf i-j. Setze b auf
ij. Wenn a lt 0 Erhöhe a um
7. Wenn b gt 6 Verringere b
um 7. Ausgabe des Spielpaars ab
Aufgabe Erläutere die folgende
Verfahrensbeschreibung anhand der oben gezeigten
"Berechnungen" für die einzelnen Spielrunden.
Wie müsste man die Verfahrensbeschreibung
abändern, damit sie für n Teilnehmer
funktioniert?
30
Fallstudie - Turnierplanung
Runde 1 7 0-17 0-27 0-37
0 01 02 03 Runde 2 7
1-1 1-27 1-37 1
11 12 13 Runde 3 7 2-1 2-2
2-37 2 21 22
23 Runde 4 Runde 5 Runde 6 7 5-1
5-2 5-3 5 51
52-7 53-7 Runde 7
Erzeugung eines Turnierplans mit 8
Teilnehmern Für i von 0 bis 6 Runde i1
Ausgabe des Spielpaars 7i Für j von 1 bis
3 Setze a auf i-j. Setze b auf
ij. Wenn a lt 0 Erhöhe a um
7. Wenn b gt 6 Verringere b
um 7. Ausgabe des Spielpaars ab
Aufgabe Implementiere das verallgemeinerte
Verfahren in Python.
31
Fallstudie - Turnierplanung
Turnierplanung spielt in etlichen Bereichen
unseres Lebens eine Rolle, z.B. bei der Planung
von Sportveranstaltungen. So müssen die Spiele
der Fußball-Bundesliga genau geplant werden,
damit ein so komplexes System bestehend aus
Mannschaften, Zuschauern, Parkleitsystemen,
Polizeieinsätzen etc. funktioniert. Bei der
Planung der Fußball-Bundesliga-Begegnungen muss -
zumindest vom Prinzip her - dasselbe Problem
gelöst werden wie beim Schulschachturnier In 17
Spielrunden muss jede der 18 Mannschaften gegen
jede andere Mannschaft antreten. Beachte, dass
die Planung des Bundesligaturnier deutlich
komplexer ist als die Planung des
Schulschachturniers Es wird eine Hin- und eine
Rückrunde so gespielt, dass jede Mannschaft
einmal Heim- und einmal Gastmannschaft ist. Nach
Möglichkeiten sollten sich Heim- und Gastspiele
abwechseln. An manchen Spieltagen steht das
Stadion durch eine andere Großveranstaltung nicht
zur Verfügung, usw..
32
Fallstudie - Turnierplanung
Früher wurde eine solch komplexe Turnierplanung
"von Hand" gemacht - wobei die Köpfe der Personen
das Planungsteams die entscheidende Rolle
gespielt haben. Turnierplanung war eine
anspruchsvolle geistige Tätigkeit, die viel Zeit
in Anspruch genommen hat. Heute kann eine
komplexe Turnierplanung mit Hilfe geeigneter
Algorithmen automatisiert durchgeführt werden.
Man gibt die Rahmenbedingungen in geeigneter Form
vor, ein Rechner ermittelt dann in kurzer Zeit
mögliche Turnierabläufe. Das Beispiel
Turnierplanung zeigt, dass geistige Tätigkeiten
heute zunehmend automatisiert werden. Algorithmen
spielen dabei eine entscheidende Rolle und
bestimmen so zunehmend große Teile unseres
Lebens. Inwieweit das gut oder schlecht ist,
musst du selbst beurteilen.
33
Teil 4
Algorithmusbegriff
34
Fallstudie - Robotersteuerung
Ein Roboter soll Ziegel transportieren. Die
Ziegel sind (wie in der Abbildung zu sehen) alle
auf einem Feld aufeinder gestapelt. Der Roboter
soll den gesamten Ziegeltum zwei Felder weiter in
Richtung Süden transportieren.
Wie könnte der Roboter das machen? Warum ist es
schwierig, ein Verfahren zur Robotersteuerung
exakt zu beschreiben?
35
Fachkonzept - Algorithmus
Ein Algorithmus ist eine Verarbeitungsvorschrift,
die so präzise formuliert ist, dass sie auch von
einer Maschine abgearbeitet werden kann.
36
Problemlöseverfahren - Version 1
Was soll ich tun?
Gehe zum Ziegelturm. Trage den Ziegelturm zwei
Felder weiter in Richtung Süden. Gehe zurück zur
Ausgangsposition.
Aufgabe Welche Schwierigkeit wird hier
beschrieben?
37
Problemlöseverfahren - Version 2

• Anweisungen
• um 90 nach rechts drehen (kurz R)
• um 90 nach links drehen (kurz L)
• einen Schritt vorwärts gehen (kurz S)
• einen Ziegel aufheben (kurz A)
• einen Ziegel hinlegen (kurz H)

R, S, L, A, L, S, S, R, H, R, S, S, L, A, L, S,
S, R, H, R, S, S, L, A, L, S, S, R, H, R, S, S,
L, A, L, S, S, R, H, R, S, S, L, L, S, R
Etwas stimmt hier nicht!
Klappt wunderbar!
Aufgabe Welche Schwierigkeit wird hier
beschrieben?
38
Problemlöseverfahren - Version 3

• Anweisungen
• um 90 nach rechts drehen (kurz R)
• um 90 nach links drehen (kurz L)
• einen Schritt vorwärts gehen (kurz S)
• einen Ziegel aufheben (kurz A)
• einen Ziegel hinlegen (kurz H)

Wie geht es hier weiter?
R
S
L
L
S
S
R
L
A
H
S
L
S
S
R
R
Aufgabe Welche Schwierigkeit wird hier
beschrieben?
39
Problemlöseverfahren - Version 4

• Bedingungen
• steht vor einem Ziegel (kurz vZ)
• ...

R, S, L wenn vZ dann A, L, S, S, R, H, R, S,
S, L wenn vZ dann A, L, S, S, R, H, R, S,
S, L wenn vZ dann A, L, S, S, R, H, R,
S, S, L wenn ... ... sonst
... sonst L, S, R sonst
L, S, R sonst L, S, R
So eine lange Vorschrift!
Aufgabe Welche Schwierigkeit wird hier
beschrieben?
40
Anforderungen an Algorithmen
Ein Algorithmus ist eine Verarbeitungsvorschrift,
die so präzise formuliert ist, dass sie auch von
einer Maschine abgearbeitet werden kann.

• Kriterien
• Ausführbarkeit, d. h. der Prozessor muss die
  Einzelschritte abarbeiten können
• Eindeutigkeit, d. h. die Abfolge der Schritte
  ist eindeutig festgelegt
• Endlichkeit, d. h. seine Beschreibung besteht
  aus einem Text endlicher Länge
• Allgemeinheit, d. h. es wird eine ganze Klasse
  von Problemen gelöst

drehe dich um 90 nach rechts gehe einen Schritt
vorwärts drehe dich um 90 nach links solange du
vor einem Ziegel stehst, tue Folgendes hebe
einen Ziegel auf drehe dich um 90 nach
links gehe einen Schritt vorwärts gehe
einen Schritt vorwärts drehe dich um 90 nach
rechts lege den Ziegel hin drehe dich um
90 nach rechts gehe einen Schritt vorwärts
gehe einen Schritt vorwärts drehe dich um
90 nach links drehe dich um 90 nach links gehe
einen Schritt vorwärts drehe dich um 90 nach
rechts
41
Anforderung - Ausführbarkeit
Ausführbarkeit bedeutet, dass der "Prozessor"
jeden Einzelschritt des Algorithmus ausführen
kann. Beachte, dass die Ausführbarkeit eines
Algorithmus immer von den Möglichkeiten des
"Prozessors" abhängt.
Was soll ich tun?
Gehe zum Ziegelturm. Trage den Ziegelturm zwei
Felder weiter in Richtung Süden. Gehe zurück zur
Ausgangsposition.
Prozessor Maschine, Person oder auch gedachte
Einheit, die den Algorithmus ausführen soll
42
Anforderung - Eindeutigkeit
Eindeutigkeit bedeutet, dass die Abfolge der
einzelnen Schritte genau festgelegt ist. Bei der
Abarbeitung der Anweisungen eines Algorithmus
muss also immer genau feststehen, wie es
weitergeht. Hieraus ergibt sich, dass ein
Algorithmus bei denselben Ausgangsdaten immer zum
selben Ergebnis kommt. Beachte, dass wir im
Rahmen der theoretischen Informatik auch eine
Form der Mehrdeutigkeit bei Algorithmen zulassen.
Wie geht es hier weiter?
R
S
L
L
S
S
R
L
A
H
S
L
S
S
R
R
43
Anforderung - Endlichkeit
Endlichkeit bedeutet, dass die Beschreibung aus
einem Text endlicher Länge besteht. Die
Endlichkeit der Darstellung ist eigentlich eine
Selbstverständlichkeit, da eine unendlich lange
Beschreibung in der Praxis nicht vorkommen kann.
R, S, L wenn vZ dann A, L, S, S, R, H, R, S,
S, L wenn vZ dann A, L, S, S, R, H, R, S,
S, L wenn vZ dann A, L, S, S, R, H, R,
S, S, L wenn ... ... sonst
... sonst L, S, R sonst
L, S, R sonst L, S, R
So eine lange Vorschrift!
44
Anforderung - Allgemeinheit
Allgemeinheit bedeutet, dass nicht nur ein
singuläres Problem, sondern eine ganze Klasse von
Problemen gelöst werden soll. Die Forderung nach
der Allgemeinheit der Problemstellung lässt man
natürlich fallen, wenn man nur an der Lösung
eines Einzelfalls interessiert ist.
Etwas stimmt hier nicht!
R, S, L, A, L, S, S, R, H, R, S, S, L, A, L, S,
S, R, H, R, S, S, L, A, L, S, S, R, H, R, S, S,
L, A, L, S, S, R, H, R, S, S, L, L, S, R
45
Experimente mit Karol
Aufgabe (a) Im Fenster links unten kannst du
dir die Anweisungen, Bedingungen und
Kontrollstrukturen anzeigen lassen, die man zur
Steuerung von Karol verwenden kann. Benutze diese
Informationen, um ein Steuerungsverfahren exakt
zu formulieren. Der Anfang eines möglichen
Steuerungsverfahrens ist im Fenster links oben zu
sehen. (b) Teste dein Steuerungsverfahren mit
verschiedenen Ziegeltürmen. Dann siehst du
direkt, ob das Verfahren korrekt ist. (c) Wenn
das Steuerungsverfahren fertig formuliert ist,
dann benutze den Menupunkt Struktogramm, um das
Verfahren grafisch in Form eines Struktogramms
darzustellen. Wie "liest" man ein solches
Struktogramm?
46
Experimente mit Karol
Aufgabe Der Roboter soll alle Ziegel, die auf
dem Weg zur nächsten Wand liegen, einsammeln und
anschließend zurück zur Ausgangsposition laufen.
Wir setzen hier voraus, dass Ziegel immer nur
einzeln (also nicht aufeinanderliegend)
vorkommen. Entwickle einen geeigneten
Algorithmus.
47
Bausteine von Algorithmen
Problem Der Roboter soll alle Ziegel, die auf
dem Weg zur nächsten Wand liegen, einsammeln und
anschließend zurück zur Ausgangsposition laufen.
Wir setzen hier voraus, dass Ziegel immer nur
einzeln (also nicht aufeinanderliegend)
vorkommen.
solange NichtIstWand tue wenn IstZiegel dann
Aufheben Schritt sonst
Schritt wenn solange RechtsDrehen RechtsDreh
en solange NichtIstWand tue
Schritt solange RechtsDrehen RechtsDrehen
48
Bausteine von Algorithmen
Elementaranweisungen sind Anweisungen, die als
Basisaktionen des Prozessors angesehen werden
können. Kontrollanweisungen sind Anweisungen,
deren Aufgabe es ist, die Ablauflogik
festzulegen. Hierzu gehören Anweisungen zur
Beschreibung von Wiederholungen,
Fallunterscheidungen und zur Sequenzbildung.
solange NichtIstWand tue wenn IstZiegel dann
Aufheben Schritt sonst
Schritt wenn solange RechtsDrehen RechtsDreh
en solange NichtIstWand tue
Schritt solange RechtsDrehen RechtsDrehen
49
Darstellung von Algorithmen
Umgangssprachlich formulierte Algorithmen
versuchen, die Idee eines Algorithmus zu
beschreiben, ohne strenge Formalien in der
Darstellung zu beachten.
Solange die Wand noch nicht erreicht ist, tue
Folgendes Wenn ein Ziegel im Weg liegt, dann
hebe ihn auf und gehen einen Schritt
weiter. Ansonsten gehe direkt einen Schritt
weiter. Drehe dich um 180 Grad. Solange die Wand
noch nicht erreicht ist, gehe einen Schritt
weiter. Drehe dich um 180 Grad.
50
Darstellung von Algorithmen
Algorithmen, die in einer Programmiersprache
verfasst sind, können direkt getestet werden
(sofern ein Ausführsystem für die
Programmiersprache bereitsteht).
solange NichtIstWand tue wenn IstZiegel dann
Aufheben Schritt sonst
Schritt wenn solange RechtsDrehen RechtsDreh
en solange NichtIstWand tue
Schritt solange RechtsDrehen RechtsDrehen
51
Darstellung von Algorithmen
Struktogramme benutzt man, um den strukturellen
Aufbau eines Algorithmus deutlich zu machen. Hier
ist insbesondere die Schachtelung der
Kontrollstrukturen zur Ablaufmodellierung
besonders gut zu erkennen.
52
Darstellung von Algorithmen
Flussdiagramme eigen sich sehr gut, um den Ablauf
bei Wiederholungen und Fallunterscheidungen zu
veranschaulichen.
53
Algorithmen im Alltag
ZUTATEN für 5 Portionen 650g Erdbeeren150g
Zucker2 Pk Vanillezucker5 EL Weinbrand400 ml
Sahne (gut gekühlt) ZUBEREITUNG Erdbeeren kalt
abbrausen, abtropfen lassen und trocken tupfen.
Blütenansatz entfernen. 150 Gramm der Früchte
zugedeckt beiseite stellen. Restliche Erdbeeren
in Stücke schneiden. Zucker, Vanillezucker und
Weinbrand darunterheben und alles 30 Minuten
zugedeckt ziehen lassen. Dann mit dem Mixstab
fein pürieren. Die Hälfte der Sahne steif
schlagen und unter das Püree ziehen. Die Creme im
Gefrierfach oder in der Tiefkühltruhe gefrieren
lassen. Restliche Sahne halbsteif schlagen. Mit
einem Esslöffel Nocken von der Mousse abstechen
und auf Dessertteller verteilen. Die halbsteife
Sahne angießen und das Dessert mit den ganzen
Erdbeeren garnieren. Quelle www.daskochrezept.de
Rezept
Bedienungs-anleitung
Auch im Alltag gibt es Verfahrensbeschreibungen,
die algorithmische Züge aufweisen. Die
Anforderungen an den "Prozessor" sind aber in der
Regel nicht so hoch wie bei Algorithmen in der
Informatik.
54
Al-Khwarizmi
Die Bezeichnung Algorithmus leitet sich aus dem
Namen Al-Khwarizmi einem arabischen
Mathematiker ab.
Abu Abd Allah Mohammed Ibn Musa Al-Khwarizmi
lebte etwa von 780 bis 850 n. Chr. Er stammte aus
Choresm (arab. Khwarizmi), eine Gegend südlich
des Aralsees, die heute Teil von Usbekistan und
Turkmenistan ist. Für seinen Namen sind mehrere
Schreibweisen gebräuchlich, z.B. Alhwarizmi,
Al-Hwarizmi, al-Khowarizmi oder auch Mohammed ben
Musa. Al-Khwarizmi beschäftigte sich u. a. mit
Verfahren zur Lösung von Gleichungen. Er
verfasste Bücher, die sich mit Algebra,
Astronomie und Geographie beschäftigten, sowie
Werke über indische Ziffern und den Jüdischen
Kalender.
55
Teil 2
Korrektheit von Algorithmen
56
Wechselwegnahme
Auf dem Tisch liegen zwei Reihen von
Streichhölzern. Von der jeweils längeren Reihe
sollen so viele weggenommen werden, wie in der
kürzeren vorkommen. Aufgehört wird, wenn beide
Streichholzreihen gleich lang sind.

• AufgabenFühre den Algorithmus mit verschiedenen
  Ausgangszahlen / Streichholzreihen durch und
  notiere die jeweiligen Ausgaben.
• x 15 y 7
• x 10 y 21
• x 3 y 20
• Was leistet der Algorithmus? Wie hängen die
  Ausgaben von den Eingaben ab?
• Ändert sich etwas am Verfahren, wenn man es wie
  unten beschreibt?

57
Spezifikation
Das Verhalten eines Algorithmus lässt sich mit
einer Spezifikation präzise beschreiben. Die
Spezifikation besteht aus einer Vorbedingung, die
den Ausgangszustand beschreibt, sowie einer
Nachbedingung, die den Endzustand beschreibt.
Vorbedingung
vorher x a (nat. Zahl) und y b (nat. Zahl)

nachher x y ggT(a, b)
Nachbedingung
58
Korrektheit
Ein Algorithmus heißt terminierend bzgl. einer
Spezifikation, wenn er bei jedem Ausgangszustand,
der die Vorbedingung erfüllt, nach endlich vielen
Verarbeitungsschritten zu einem Ende kommt. Ein
Algorithmus heißt (total) korrekt bzgl. einer
Spezifikation, wenn er terminierend ist und jeden
Ausgangszustand, der die Vorbedingung erfüllt, in
einen Endzustand überführt, der die Nachbedingung
erfüllt.
vorher x a (nat. Zahl) und y b (nat. Zahl)

vorher x a (nat. Zahl) und y b (nat. Zahl)

korrekt
nicht terminierend
nachher x y ggT(a, b)
nachher x y ggT(a, b)
59
Korrektheitsnachweis über Testen
Beim Testen eines Algorithmus wird der
Algorithmus bei bestimmten vorgegebenen Testdaten
ausgeführt und dabei überprüft, ob er in diesen
Fällen das gewünschte Verhalten zeigt. Mit dieser
Methode kann man das Vorhandensein von Fehlern
entdecken. Man kann aber in der Regel nicht
nachweisen, dass der Algorithmus korrekt bzgl.
der gegebenen Spezifikation ist.
vorher x a (nat. Zahl) und y b (nat. Zahl)

vorher x a (nat. Zahl) und y b (nat. Zahl)

x 8 y 8 nicht terminierend
x 15 y 7 ok
x 8 y 8 ok
...
nachher x y ggT(a, b)
nachher x y ggT(a, b)
60
Teststrategien
Testdaten sollten immer sorgfältig ausgewählt
werden. Man sollte sowohl typische als auch
untypische Eingabewerte betrachten. Besondere
Aufmerksamkeit ist auf Sonderfälle und Grenzwerte
zu richten. Unter letzteren versteht man Werte,
die gerade noch als Eingabewerte zugelassen sind
(z. B. größter und kleinster Wert, leerer Text,
leere Eingabe usw.). Oft ist es auch günstig,
zufällig erzeugte Testdaten zu verwenden.
Bei der Durchführung von Tests sollte man vorher
notieren, welche Ausgabe das Programm laut
Spezifikation liefern soll. Danach überprüft man,
ob der Algorithmus tatsächlich dieses Verhalten
zeigt. In einem Exkurs zur Testausführung mit
Python zeigen wir, wie solche Testfälle in
lauffähige Implementierungen von Algorithmen
integriert werden können.
61
Testen mit Python
Es gibt verschiedene Möglichkeiten, einen
Algorithmus in Python zu testen.
Implementierung des Algorithmus
Wechselwegnahme def ggt(x, y) while x !
y if x gt y x x - y
else y y - x return x
Test print("ggt(44, 12) ", ggt(44,
12)) print("ggt(7, 13) ", ggt(7,
13)) print("ggt(4, 4) ", ggt(4,
4)) print("ggt(1, 6) ", ggt(1,
6)) print("ggt(6, 18) ", ggt(6, 18))
gtgtgt ggt(44, 12) 4 ggt(7, 13) 1 ggt(4, 4)
4 ggt(1, 6) 1 ggt(6, 18) 6
Testergebnisse
Testfälle
62
Testen mit Python
Es gibt verschiedene Möglichkeiten, einen
Algorithmus in Python zu testen.
def ggt(x, y) """ groesster gemeinsamer
Teiler gtgtgt ggt(44, 12) 4 gtgtgt ggt(7,
13) 1 gtgtgt ggt(4, 4) 4
""" while x ! y if x gt y
x x - y else y y - x
return x if __name__ "__main__"
import doctest doctest.testmod(verboseTrue)
gtgtgt Trying ggt(44, 12) Expecting
4 ok Trying ggt(7, 13) Expecting
1 ok Trying ggt(4, 4) ... 1 items had no
tests __main__ 1 items passed all tests
3 tests in __main__.ggt 3 tests in 2 items. 3
passed and 0 failed. Test passed.
von Python erzeugtes Testprotokoll
vorher festgelegte Testfälle mit erwarteten
Ergebnissen
63
Exkurs Verifikation von Algorithmen
Behauptung Der Wechselwegnahme-Algorithmus ist
korrekt bzgl. der angegebenen Spezifikation.
Beweis Wir zeigen zunächst, dass die Bedingung
ggT(x, y) ggT(a, b) vor dem ersten und nach
jedem Schleifendurchlauf erfüllt ist. Vor dem
ersten Schleifendurchlauf gilt selbstverständlich
diese Bedingung, da hier x a und y b
gilt. Als nächstes zeigen wir, dass die genannte
Bedingung nach einem Schleifendurchlauf noch
gilt, sofern sie vorher bereits erfüllt war. Wir
nehmen also an, dass die Bedingung ggT(x, y)
ggT(a, b) vor der Ausführung der Anweisungen der
Schleife gilt. Die Werte der Variablen x und y
nach der Ausführung der Schleife bezeichnen wir
mit x' und y'. Es gilt x' x - y und y' y oder
x' x und y' y - x. Jetzt nutzen wir eine
allgemeine Eigenschaft des ggT aus Für beliebige
natürliche Zahlen m und n mit m gt n gilt ggT(m,
n) ggT(m-n, n). Diese Eigenschaft kann man
leicht mathematisch beweisen. Aus ihr folgt, dass
in jedem Fall ggT(x', y') ggT(x, y) gelten
muss. Da ggT(x, y) ggT(a, b) vorausgesetzt war,
folgt, dass ggT(x', y') ggT(a, b) gilt.
Zusatzüberlegung Für m gt n gilt Wenn a m und
a n,dann a (m-n). Wenn a (m-n) und a
n, dann a m. Hieraus folgt ggT(m, n)
ggT(m-n, n).
64
Exkurs Verifikation von Algorithmen
Fortsetzung des Beweises Kommt es zum Verlassen
der Schleife, so gilt einerseits ggT(x, y)
ggT(a, b), da diese Bedingung vor dem ersten
Schleifendurchlauf gilt und wie gezeigt nach
jedem weiteren Durchlauf. Andererseits gilt auch
x y, da nur bei dieser Bedingung die Schleife
verlassen wird. Da der ggT bei zwei gleichen
Zahlen mit dieser Zahl übereinstimmt, muss also
ggT(a, b) ggT(x, y) x y gelten. Hiermit
ist gezeigt, dass die Nachbedingung erfüllt ist,
sofern die Vorbedingung gilt und der Algorithmus
bei den gegebenen Daten terminiert. Zuletzt muss
jetzt nur noch gezeigt werden, dass der
Algorithmus bei sämtlichen möglichen Eingabedaten
tatsächlich terminiert. Dies kann man sich aber
schnell klar machen. Man beginnt mit zwei
natürlichen Zahlen x a und y b. In jedem
Schleifendurchlauf wird eine der beiden Zahlen
verkleinert. Man kann nicht unendlich oft eine
der beiden Zahlen verkleinern, so dass beide
größer als Null und auch verschieden bleiben.
65
Teil 3
Effizienz von Algorithmen
66
ggT-Berechnung
Der ggT von x 3642431875 und y 15 soll
berechnet werden.
Aufgaben Würde man hier wirklich den
Wechselwegnahme-Algorithmus ausführen? Was
spricht dagegen? Wie könnte man effizienter
vorgehen? Bedenken Sie, mit welcher
Rechenoperation man wiederholte Subtraktionen
schneller ausführen kann. Entwickeln Sie einen
geeigneten Algorithmus.
67
Effizienz
Der ggT von x 3642431875 und y 15 soll
berechnet werden.
x 3642431875 y 15 x 3642431860 y 15 x
3642431845 y 15 ... x 5 y 5
x 3642431875 y 15 x 15 y 5 x 5 y 0
äquivalent
äquivalent
effizienter
68
Effizienz
Zwei Algorithmen heißen äquivalent, wenn sie bei
gleichen Ausgangszuständen jeweils gleiche
Endzustände erzeugen. Von zwei äquivalenten
Algorithmen heißt der effizienter, der mit
weniger Ressourcen (d. h. Rechenzeit oder
Speicherplatz) auskommt.
äquivalent
äquivalent
effizienter
69
Laufzeitmessung mit Python
Es gibt verschiedene Möglichkeiten, den Aufwand
eines Algorithmus in Python zu messen.
Deklaration def ggt(x, y) while x ! y
if x gt y x x - y
else y y - x return x Test
mit Laufzeitmessung from time import t1
clock() z ggt(3642431875, 15) t2 clock() t
t2 - t1 print("ggt(3642431875, 15) ",
z) print("Rechenzeit ", t
"interne Uhr"
gtgtgt ggt(3642431875, 15) 5 Rechenzeit
160.503182108
70
Laufzeitmessung mit Python
Aufgabe (a) Probiere das selbst aus. Bestimme
entsprechend die Rechenzeit für a 44 und b 8
beim Euklidischen Algorithmus. (b) Bestimme die
Rechenzeiten bei beiden Algorithmen für a
3642431875 und b 15. Kannst du erklären, warum
es hier zu einem so großen Unterschied kommt?
71
Aktionen zählen mit Python
Es gibt verschiedene Möglichkeiten, den Aufwand
eines Algorithmus in Python zu messen.
def ggt(x, y) z 0 while x ! y
z z 1 if x gt y x x -
y else y y - x return
x, z if __name__ "__main__" zahl1
3642431875 zahl2 15 (ergebnis, anzahl)
ggt(zahl1, zahl2) print("Zahl 1 ", zahl1,
"Zahl 2 ", zahl2, "ggt ", ergebnis)
print("Schleifendurchlaeufe ", anzahl)
Zähler für Schleifendurchläufe
Ausgabe der Ergebnisse
gtgtgt Zahl 1 3642431875 Zahl 2 15 ggt
5 Schleifendurchlaeufe 242828793
72
Aktionen zählen mit Python
Aufgabe (a) Probiere das selbst aus. Bestimme
entsprechend die Anzahl der Schleifendurchläufe
für a 44 und b 8 beim Euklidischen
Algorithmus. (b) Bestimme die Anzahl der
Schleifendurchläufe bei beiden Algorithmen für a
3642431875 und b 15. Kannst du erklären,
warum es hier zu einem so großen Unterschied
kommt?
73
Teil 5
Rekursive Algorithmen
74
Türme von Hanoi
Einer Geschichte zufolge soll im Tempel zu
Benares - das ist eine "heilige Stadt" in Indien
- ein Turm aus 64 goldenen, der Größe nach
geordneten Scheiben stehen. Die Mönche des
Tempels erhalten die Aufgabe, die Scheiben an
einen anderen Ort zu bringen. Dabei müssen sie
einige Regeln beachten Es darf immer nur eine
Scheibe transportiert werden. Scheiben können
auf einem (einzigen) Hilfsstapel zwischenzeitlich
abgelegt werden. Auch auf dem (teilweise
abgebauten) Ausgangsturm können Scheiben
zwischenzeitlich abgelegt werden. Es darf aber
nie eine größere Scheibe auf eine kleinere gelegt
werden. Wenn der neue Turm fertig ist, dann ist
das Ende der Zeit erreicht.
75
Türme von Hanoi
Aufgabe Versuche, einen Turm mit 5 Scheiben nach
den vorgegebenen Regeln umzustapeln. Wenn das
nicht klappt, dann versuche erst einmal, Türme
mit 3 bzw. 4 Scheiben umzustapeln.
Ausgangszustand
Zielzustand
Benutze hierzu Münzen unterschiedlicher Größe
oder ein Simulationsprogramm.z. B.
http//www.mpg-trier.de/d7/prog/hanoi/hanoi.htm
76
Türme von Hanoi
Aufgabe Überlege dir auch eine Strategie, mit
der man Türme mit 6, 7, ... Scheiben umstapeln
kann.
Ausgangszustand
Zielzustand
77
Lösungsidee
transportiere einen 5-Scheiben-Turm von A über B
nach C
Ausgangszustand
transportiere einen 4-Scheiben-Turm von A über C
nach B
Zwischenzustand
transportiere eine Scheibe von A nach C
Zwischenzustand
transportiere einen 4-Scheiben-Turm von B über A
nach C
Zielzustand
78
Verallgemeinerung
transportiere einen n-Scheiben-Turm von X über Y
nach Z
Ausgangszustand
transportiere einen (n-1)-Scheiben-Turm von X
über Z nach Y
Zwischenzustand
transportiere eine Scheibe von X nach Z
Zwischenzustand
transportiere einen (n-1)-Scheiben-Turm von Y
über X nach Z
Zielzustand
79
Algorithmus
Algorithmus transportiere einen n-Scheiben-Turm
von X über Y nach Z wenn n gt 1
transportiere einen (n-1)-Scheiben-Turm von X
über Z nach Y transportiere eine Scheibe
von X nach Z transportiere einen
(n-1)-Scheiben-Turm von Y über X nach Z
sonst transportiere eine Scheibe von X
nach Z
80
Rekursive Problemreduktion
Rekursive Problemreduktion ist eine
Problemlösestrategie, bei der ein Problem auf ein
strukturgleiches Problem (in verkleinerter Form)
zurückgeführt wird.
Algorithmus transportiere einen n-Scheiben-Turm
von X über Y nach Z wenn n gt 1
transportiere einen (n-1)-Scheiben-Turm von X
über Z nach Y transportiere eine Scheibe
von X nach Z transportiere einen
(n-1)-Scheiben-Turm von Y über X nach Z
sonst transportiere eine Scheibe von X
nach Z
Ein rekursiver Algorithmus ruft sich (eventuell
über Umwege) selbst auf und nutzt sich so selbst
zur Beschreibung der Lösung des gegebenen
Problems.
Um Rekursion als Problemlösestrategie nutzen zu
können, benötigt man ein Ausführsystem, das in
der Lage ist, rekursive Algorithmen wiederholt
aufzurufen und auf diese Weise die eigentliche
Lösung zu generieren.
81
Ausführung des Algorithmus
Algorithmus transportiere einen n-Scheiben-Turm
von X über Y nach Z wenn n gt 1
transportiere einen (n-1)-Scheiben-Turm von X
über Z nach Y transportiere eine Scheibe
von X nach Z transportiere einen
(n-1)-Scheiben-Turm von Y über X nach Z
sonst transportiere eine Scheibe von X
nach Z
Ausführungstiefe 1
transportiere einen 3-Scheiben-Turm von A über B
nach C transportiere einen 2-Scheiben-Turm
von A über C nach B transportiere eine
Scheibe von A nach C transportiere einen
2-Scheiben-Turm von B über A nach C
82
Ausführung des Algorithmus
Algorithmus transportiere einen n-Scheiben-Turm
von X über Y nach Z wenn n gt 1
transportiere einen (n-1)-Scheiben-Turm von X
über Z nach Y transportiere eine Scheibe
von X nach Z transportiere einen
(n-1)-Scheiben-Turm von Y über X nach Z
sonst transportiere eine Scheibe von X
nach Z
Ausführungstiefe 2
transportiere einen 3-Scheiben-Turm von A über B
nach C transportiere einen 2-Scheiben-Turm
von A über C nach B transportiere einen
1-Scheiben-Turm von A über B nach C
transportiere eine Scheibe von A nach B
transportiere einen 1-Scheiben-Turm von C über A
nach B transportiere eine Scheibe von A nach
C transportiere einen 2-Scheiben-Turm von B
über A nach C transportiere einen
1-Scheiben-Turm von B über C nach A
transportiere eine Scheibe von B nach C
transportiere einen 1-Scheiben-Turm von A über B
nach C
83
Ausführung des Algorithmus
Algorithmus transportiere einen n-Scheiben-Turm
von X über Y nach Z wenn n gt 1
transportiere einen (n-1)-Scheiben-Turm von X
über Z nach Y transportiere eine Scheibe
von X nach Z transportiere einen
(n-1)-Scheiben-Turm von Y über X nach Z
sonst transportiere eine Scheibe von X
nach Z
Ausführungstiefe 3
transportiere einen 3-Scheiben-Turm von A über B
nach C transportiere einen 2-Scheiben-Turm
von A über C nach B transportiere einen
1-Scheiben-Turm von A über B nach C
transportiere eine Scheibe von A nach C
transportiere eine Scheibe von A nach B
transportiere einen 1-Scheiben-Turm von C über A
nach B transportiere eine Scheibe
von C nach B transportiere eine Scheibe von A
nach C transportiere einen 2-Scheiben-Turm
von B über A nach C transportiere einen
1-Scheiben-Turm von B über C nach A
transportiere eine Scheibe von B nach A
transportiere eine Scheibe von B nach C
transportiere einen 1-Scheiben-Turm von A über B
nach C transportiere eine Scheibe
von A nach C
84
Ausführung des Algorithmus
transportiere einen 3-Scheiben-Turm von A über B
nach C transportiere einen 2-Scheiben-Turm
von A über C nach B transportiere einen
1-Scheiben-Turm von A über B nach C
transportiere eine Scheibe von A nach C
transportiere eine Scheibe von A nach B
transportiere einen 1-Scheiben-Turm von C über A
nach B transportiere eine Scheibe
von C nach B transportiere eine Scheibe von A
nach C transportiere einen 2-Scheiben-Turm
von B über A nach C transportiere einen
1-Scheiben-Turm von B über C nach A
transportiere eine Scheibe von B nach A
transportiere eine Scheibe von B nach C
transportiere einen 1-Scheiben-Turm von A über B
nach C transportiere eine Scheibe
von A nach C
Basisaktionen
85
Implementierung in Python
Algorithmus transportiere einen n-Scheiben-Turm
von X über Y nach Z wenn n gt 1
transportiere einen (n-1)-Scheiben-Turm von X
über Z nach Y transportiere eine Scheibe
von X nach Z transportiere einen
(n-1)-Scheiben-Turm von Y über X nach Z
sonst transportiere eine Scheibe von X
nach Z
Algorithmus
def transportiereTurm(n, x, y, z) if n gt 1
transportiereTurm(n-1, x, z, y)
print("transportiere eine Scheibe von ", x, "
nach ", z) transportiereTurm(n-1, y, x,
z) else print("transportiere eine
Scheibe von ", x, " nach ", z)
Python-Programm
Aufgabe Teste die Implementierung des
Algorithmus "Türme von Hanoi" mit verschiedenen
n-Werten.
86
Implementierung in Python
Aufgabe Die Prozedur aus Aufgabe 1 ist um eine
print-Anweisung erweitert worden. Kannst du ohne
es auspobiert zu haben vorhersagen, welche
Ausgaben die Prozedur beim Aufruf
transportiereTurm(3, 'A', 'B', 'C') auf dem
Bildschirm macht? Überprüfe dein Ergebnis.
def transportiereTurm(n, x, y, z)
print("transportiere einen ", n, " -Scheiben-Turm
von ", x, " nach ", z) if n gt 1
transportiereTurm(n-1, x, z, y)
print("transportiere eine Scheibe von ", x, "
nach ", z) transportiereTurm(n-1, y, x,
z) else print("transportiere eine
Scheibe von ", x, " nach ", z)
87
Teil 6
Fallstudie - Selbstähnliche Figuren
88
Einstieg - Selbstähnliche Figur
Eine Figur ist selbstähnlich, wenn sie sich in
Teile zerlegen lässt, die zur ihr ähnlich sind.
89
Einstieg - Selbstähnliche Figur
Eine Figur ist selbstähnlich, wenn sie sich in
Teile zerlegen lässt, die zur ihr ähnlich sind.
zeichne_Baum(200) gehe_vorwaerts(200)
drehe_dich_nach_rechts(45) zeichne_Baum(100)
drehe_dich_nach_links(90)
zeichne_Baum(100) drehe_dich_nach_rechts(45)
gehe_rueckwaerts(200)
ALG zeichne_Baum(x) wenn x gt 2
gehe_vorwaerts(x) drehe_dich_nach_rechts(4
5) zeichne_Baum(x/2)
drehe_dich_nach_links(90)
zeichne_Baum(x/2) drehe_dich_nach_rechts(4
5) gehe_rueckwaerts(x)
rekursive Problemreduktion
rekursiver Algorithmus
90
Exkurs - Turtle-Grafik
Turtle-Grafik basiert auf der Vorstellung, dass
eine Schildkröte mit bestimmten Anweisungen auf
einer Zeichenfläche bewegt wird und dass die
Schildkröte dabei eine Spur hinterlässt.
vorwaerts(100)
Turtle-Befehle

• stift_hoch
• stift_runter
• gehe_vorwaerts(betrag)
• gehe_rueckwaerts(betrag)
• drehe_dich_nach_links(winkel)
• drehe_dich_nach_rechts(winkel)
• gehe_zu_punkt(punkt)
• ...

zeichne_Quadrat(laenge) wiederhole 4 mal
gehe_vorwaerts(laenge)
drehe_dich_nach_links(90)
Turtle-Algorithmus
91
Exkurs - Turtle-Grafik in Python
Turtle-Grafik basiert auf der Vorstellung, dass
eine Schildkröte mit bestimmten Anweisungen auf
einer Zeichenfläche bewegt wird und dass die
Schildkröte dabei eine Spur hinterlässt.
zeichne_Quadrat(laenge) wiederhole 4 mal
gehe_vorwaerts(laenge)
drehe_dich_nach_links(90)

• stift_hoch
• stift_runter
• gehe_vorwaerts(betrag)
• gehe_rueckwaerts(betrag)
• drehe_dich_nach_links(winkel)
• drehe_dich_nach_rechts(winkel)
• gehe_zu_punkt(punkt)
• ...

Turtle-Programm
from turtle import Deklaration einer
Zeichenprozedur def quadrat(laenge) for i in
range(4) t.forward(laenge)
t.left(90) Erzeugung eines Turtle-Objekts t
Turtle() Test der Zeichenprozedur quadrat(100)
Turtle-Klasse
gtgtgt from turtle import gtgtgt t Turtle() gtgtgt
t.forward(100) gtgtgt bye()
t.forward(100)
92
Exkurs - Turtle-Grafik in Python
from turtle import Deklaration einer
Zeichenprozedur def baum(stamm) if stamm gt
2 t.forward(stamm) t.right(45)
baum(stamm/2) t.left(90)
baum(stamm/2) t.right(45)
t.backward(stamm) Erzeugung eines
Turtle-Objekts t Turtle() Test der
Zeichenprozedur t.left(90) baum(200)
ALG zeichne_Baum(x) wenn x gt 2
gehe_vorwaerts(x) drehe_dich_nach_rechts(4
5) zeichne_Baum(x/2)
drehe_dich_nach_links(90)
zeichne_Baum(x/2) drehe_dich_nach_rechts(4
5) gehe_rueckwaerts(x)
93
Übungen
Wählen Sie eine der folgenden selbstähnlichen
Figuren aus. Entwickeln Sie mit Hilfe einer
rekursive Problemreduktion einen rekursiven
Algorithmus zum Zeichnen der Figur. Testen Sie
den Algorithmus mit einer Python-Implementierung.
94
Übungen
Wählen Sie eine der folgenden selbstähnlichen
Figuren aus. Entwickeln Sie mit Hilfe einer
rekursive Problemreduktion einen rekursiven
Algorithmus zum Zeichnen der Figur. Testen Sie
den Algorithmus mit einer Python-Implementierung.
95
Übungen
Wählen Sie eine der folgenden selbstähnlichen
Figuren aus. Entwickeln Sie mit Hilfe einer
rekursive Problemreduktion einen rekursiven
Algorithmus zum Zeichnen der Figur. Testen Sie
den Algorithmus mit einer Python-Implementierung.
96
Übungen
Wählen Sie eine der folgenden selbstähnlichen
Figuren aus. Entwickeln Sie mit Hilfe einer
rekursive Problemreduktion einen rekursiven
Algorithmus zum Zeichnen der Figur. Testen Sie
den Algorithmus mit einer Python-Implementierung.
97
Übungen
Wählen Sie eine der folgenden selbstähnlichen
Figuren aus. Entwickeln Sie mit Hilfe einer
rekursive Problemreduktion einen rekursiven
Algorithmus zum Zeichnen der Figur. Testen Sie
den Algorithmus mit einer Python-Implementierung.
98
Übungen
Wählen Sie eine der folgenden selbstähnlichen
Figuren aus. Entwickeln Sie mit Hilfe einer
rekursive Problemreduktion einen rekursiven
Algorithmus zum Zeichnen der Figur. Testen Sie
den Algorithmus mit einer Python-Implementierung.
99
Teil 6
Übungen - Rekursive Verarbeitung von Listen
100
Einstieg - Geschachtelte Listen
Eine Gästeliste soll mit einem Programm verwaltet
und verarbeitet werden.
gaeste "Ursula", "Winfried", "Ulrike",
"Klaus", ...
def ausgabe(liste) i 0 while i lt
len(liste) element listei
print(element) i i 1
def ausgabe(liste) if len(liste) 0
pass else erstesElement
liste0 restListe liste1
print(erstesElement) ausgabe(restListe)
iterativ
rekursiv
Test ausgabe(gaeste)
101
Einstieg - Geschachtelte Listen
Eine Gästeliste soll mit einem Programm verwaltet
und verarbeitet werden.
gaeste "Ursula", "Winfried",
"Ulrike", "Klaus", "Christiane", "Tim",
"Andreas", "Ulrike", "Peter",
"Kea", "Lena", "Paula", ...
def ausgabe(liste) if len(liste) 0
pass else erstesElement
liste0 restListe liste1 if
type(erstesElement) list
ausgabe(erstesElement) else
print(erstesElement) ausgabe(restListe)
?
iterativ
rekursiv
Test ausgabe(gaeste)
102
Einstieg - Geschachtelte Listen
ausgabe("Ursula", "Winfried", "Ulrike",
"Klaus", "Christiane", "Tim", ...)
ausgabe("Ursula", "Winfried")
print("Ursula") ausgabe("Winfried")
print("Winfried")
ausgabe() pass
ausgabe("Ulrike", "Klaus", "Christiane",
"Tim", ... ausgabe("Ulrike",
"Klaus") print("Ulrike")
ausgabe("Klaus") print("Klaus")
ausgabe() pass
ausgabe("Christiane", "Tim", ...)
...
def ausgabe(liste) if len(liste) 0
pass else erstesElement
liste0 restListe liste1 if
type(erstesElement) list
ausgabe(erstesElement) else
print erstesElement ausgabe(restListe)
Ausführung
rekursiver Algorithmus
103
Liste als rekursive Datenstruktur
Eine Liste ist entweder eine leere Liste, oder
besteht aus einem ersten Element und einer
(Rest-)Liste.
def ausgabe(liste) if len(liste) 0
liste
pass else liste
erstesElement restListe
erstesElement liste0 restListe
liste1 if type(erstesElement)
list ausgabe(erstesElement)
else print(erstesElement)
ausgabe(restListe)
def ausgabe(liste) if len(liste) 0
liste pass else
liste erstesElement restListe
erstesElement liste0 restListe
liste1 print(erstesElement)
ausgabe(restListe)
104
Entwicklung rekursiver Algorithmen
Problem Es soll gezählt werden, wie oft ein
Element in einer Liste vorkommt.
Fall 1 Bearbeite eine leere Liste
anzahl('b', ) -gt 0
Reduktionsanfang Löse das Problem direkt
Fall 2 Bearbeite eine nicht-leere Liste
Rekursionsschritt Löse ein entsprechendes
Problem
anzahl('b', 'b', 'b', 'd', 'a', 'c', 'b') -gt
1 anzahl('b', 'b', 'd', 'a', 'c',
'b') anzahl('b', 'a', 'b', 'b', 'd', 'a', 'c',
'b') -gt anzahl('b', 'b', 'b', 'd', 'a',
'c', 'b')
Rekursive Problemreduktion Reduziere des
Problems auf ein entsprechendes, aber
verkleinertes Problem.
105
Entwicklung rekursiver Algorithmen
Problem Es soll gezählt werden, wie oft ein
Element in einer Liste vorkommt.
anzahl('b', ) -gt 0 anzahl('b', 'b', 'b',
'd', 'a', 'c', 'b') -gt 1 anzahl('b', 'b',
'd', 'a', 'c', 'b') anzahl('b', 'a', 'b', 'b',
'd', 'a', 'c', 'b') -gt anzahl('b', 'b',
'b', 'd', 'a', 'c', 'b')
def anzahl(element, liste) if len(liste)
0 re