Eigenschaften von Algorithmen

Klaus Becker

2008

2 Algorithmen

Zielsetzung: klassische Algorithmen erkunden und dabei zentrale Eigenschaften von Algorithmen klären

3 Teil 1

Algorithmusbegriff

4

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.muenster.de/mauritz//matheserver/teller/aegypten/zahl2.html

Ägyptische MultiplikationAlgorithmen werden seit den Anfängen der Mathematik beim Rechnen benutzt.

Im "Papyrus Rhind" wird beschrieben, wie in Ägypten Zahlen multipliziert wurden.

13 12∙

= 156

5 AufgabeFinden Sie heraus, wie das Verfahren der Ägypter funktioniert.Berechnen Sie mit dem Verfahren die folgenden Produkte: 15 * 14 =9 * 120 =16 * 7 =Überprüfen Sie auch, ob die Ergebnisse stimmen.Für Experten: Warum berechnet dieses merkwürdige Verdopplungs- und Halbierungsverfahren das Produkt von zwei vorgegebenen Zahlen? Versuchen Sie sich dies klar zu machen.

6 AufgabeSchreiben Sie eine möglichst präzise Anleitung, nach der jemand, der das Verfahren der Ägypter nicht kennt, zwei Zahlen multiplizieren soll.

13

6

3

1

12

24

48

96

156

13 12∙

= 156

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

13

6

3

1

12

24

48

96

156

13 12∙

= 156

8 Verfahrensbeschreibung

Struktogramm

Bedingung Anweisung z1 z2 p

13 12 p := 0 0z1 > 0 (w)z1 ungerade (w) p := p + z2 12 z1 := z1 / 2 6 z2 := z2 * 2 24z1 > 0 (w)z1 ungerade (f) z1 := z1 / 2 3 z2 := z2 * 2 48 z1 > 0 (w)z1 ungerade (w) p := p + z2 60 z1 := z1 / 2 1 z2 := z2 * 2 96z1 > 0 (w)z1 ungerade (w) p := p + z2 156 z1 := z1 / 2 0 z2 := z2 * 2 192z1 > 0 (f)

Trace / Ablaufprotokoll

13

6

3

1

12

24

48

96

156

13 12∙

= 156

9 Algorithmus

Ein Algorithmus ist eine Verarbeitungsvorschrift, die so präzise formuliert ist, dass sie auch von einer Maschine abgearbeitet werden kann.

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

6

3

1

12

24

48

96

156

13 12∙

= 156

10 Kriterien für Algorithmen

Ein Algorithmus ist eine Verarbeitungsvorschrift, die folgende Kriterien erfüllt:

Eindeutigkeit, d. h. die einzelnen Schritte und ihre Abfolge sind unmissverständlich beschrieben

Ausführbarkeit, d. h. der Prozessor muss die Einzelschritte abarbeiten können

Allgemeinheit, d. h. es wird nicht nur ein Problem, sondern eine ganze Klasse von Problemen gelöst

Endlichkeit, d. h. seine Beschreibung besteht aus einem Text endlicher Länge

Prozessor: Maschine, Person oder auch gedachte Einheit verstanden, die den Algorithmus ausführen soll

11 Algorithmen im AlltagZUTATEN 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

Bedienungs-anleitung

Rezept

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.

12 Al-Khwarizmi

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.

Die Bezeichnung „Algorithmus“ leitet sich aus dem Namen „Al-Khwarizmi“ – einem arabischen Mathematiker – ab.

13 Bausteine von Algorithmen

Eine Elementaranweisung beschreibt eine Basisaktion des betrachteten Prozessors.

S

F

W

E

E

S

E

E

E

E

S

S

Kontrollstrukturen dienen dazu, den Ablauf der Ausführungsschritte festzulegen. Wesentliche Kontrollstrukturen sind die Fallunterscheidung, die Wiederholung sowie die Sequenzbildung (Hintereinanderreihung).

E Eingabe: zahl1

Eingabe: zahl2

produkt = 0

produkt = produkt + zahl2

zahl1 = zahl1 / 2

zahl2 = zahl2 * 2

Ausgabe: produkt

14 Darstellung von Algorithmen

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.

Algorithmen lassen sich auf unterschiedliche Weise darstellen:

# Eingabezahl1 = input("Zahl 1: ")zahl2 = input("Zahl 2: ")# Verarbeitungprodukt = 0while zahl1 > 0: if zahl1 % 2 == 1: produkt = produkt + zahl2 zahl1 = zahl1 / 2 zahl2 = zahl2 * 2# Ausgabeprint "Produkt: ", produkt

Struktogramm

umgangssprachlich

Programm

15 Implementierung in Python

Es gibt verschiedene Möglichkeiten, einen Algorithmus in Python zu implementieren.# Eingabezahl1 = input("Zahl 1: ")zahl2 = input("Zahl 2: ")# Verarbeitungprodukt = 0while zahl1 > 0: if zahl1 % 2 == 1: produkt = produkt + zahl2 zahl1 = zahl1 / 2 zahl2 = zahl2 * 2# Ausgabeprint "Produkt: ", produkt

def multiplikation(zahl1, zahl2): produkt = 0 while zahl1 > 0: if zahl1 % 2 == 1: produkt = produkt + zahl2 zahl1 = zahl1 / 2 zahl2 = zahl2 * 2 return produkt

Folge von Anweisungen

>>> Zahl 1: 12Zahl 2: 13Produkt: 156

>>> multiplikation(12, 13)156

Funktions-deklaration

16 Implementierung in Scratch

17 Aufgaben

siehe www.inf-schule.de

18

Exkurs: Mathematischer Hintergrund

13 = 6*2+1

= (3*2+0)*2+1

= ((1*2+1)*2+0)*2+1

= (((0*2+1)*2+1)*2+0)*2+1

= 0*2*2*2*2 + 1*2*2*2 + 1*2*2 + 0*2 + 1

13 * 12 =

(1*2^3 + 1*2^2 + 0*2^1 + 1*2^0) * 12 =

8*12 + 4*12 + 0 + 1*12 =

96 + 48 + 12 =

156

13

6

3

1

12

24

48

96

156

Der erste Faktor wird implizit in Binärdarstellung umgewandelt. Hierdurch wird die Multiplikation auf Verdoppeln und Halbieren reduziert.

Bedingung Anweisung z1 z2 p

13 12 p := 0 0z1 > 0 (w)z1 ungerade (w) p := p + z2 12 z1 := z1 / 2 6 z2 := z2 * 2 24z1 > 0 (w)z1 ungerade (f) z1 := z1 / 2 3 z2 := z2 * 2 48 z1 > 0 (w)z1 ungerade (w) p := p + z2 60 z1 := z1 / 2 1 z2 := z2 * 2 96z1 > 0 (w)z1 ungerade (w) p := p + z2 156 z1 := z1 / 2 0 z2 := z2 * 2 192z1 > 0 (f)

19 Teil 2

Korrektheit von Algorithmen

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

Aufgaben:Fü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?

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

vorher:{ x = a (nat. Zahl) und y = b (nat. Zahl) }

nachher:{ x = y = ggT(a, b) }

Vorbedingung

Nachbedingung

22 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) }

nachher:{ x = y = ggT(a, b) }

korrektnicht terminierend

vorher:{ x = a (nat. Zahl) und y = b (nat. Zahl) }

nachher:{ x = y = ggT(a, b) }

23 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) }

nachher:{ x = y = ggT(a, b) }

x = 8; y = 8: nicht

terminierend

vorher:{ x = a (nat. Zahl) und y = b (nat. Zahl) }

nachher:{ x = y = ggT(a, b) }

x = 15; y = 7: ok

x = 8; y = 8: ok

...

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

25 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 > y: x = x - y else: y = y - x return x

# Test

if __name__ == "__main__": 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)

Testfälle

>>> ggt(44, 12) = 4ggt(7, 13) = 1ggt(4, 4) = 4ggt(1, 6) = 1ggt(6, 18) = 6

Testergebnisse

26 Testen mit Python

Es gibt verschiedene Möglichkeiten, einen Algorithmus in Python zu testen.

def ggt(x, y): """ groesster gemeinsamer Teiler

>>> ggt(44, 12) 4 >>> ggt(7, 13) 1 >>> ggt(4, 4) 4 """ while x <> y: if x > y: x = x - y else: y = y - x return x

if __name__ == "__main__": import doctest doctest.testmod(verbose=True)

>>> Trying: ggt(44, 12)Expecting: 4okTrying: ggt(7, 13)Expecting: 1okTrying: ggt(4, 4)...1 items had no tests: __main__1 items passed all tests: 3 tests in __main__.ggt3 tests in 2 items.3 passed and 0 failed.Test passed.

von Python erzeugtes

Testprotokoll

vorher festgelegte Testfälle mit erwarteten Ergebnissen

27

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

Für m > 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).

28

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.

29 Teil 3

Effizienz von Algorithmen

30 ggT-BerechnungDer 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.

31 Effizienz

äquivalent

äquivalent

effizienter

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

Der ggT von x = 3642431875 und y = 15 soll berechnet werden.

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

vorher:{ x = a (nat. Zahl) und y = b (nat. Zahl) }

nachher:{ x = y = ggT(a, b) }

äquivalent

vorher:{ x = a (nat. Zahl) und y = b (nat. Zahl) }

nachher:{ x = y = ggT(a, b) }

äquivalent

effizienter

33 Laufzeitmessung mit Python

Es gibt verschiedene Möglichkeiten, den Aufwand eines Algorithmus in Python zu messen.# Deklarationdef ggt(x, y): while x <> y: if x > y: x = x - y else: y = y - x return x

# Test mit Laufzeitmessungfrom time import *t1 = clock()z = ggt(3642431875, 15)t2 = clock()t = t2 - t1print "ggt(3642431875, 15) = ", zprint "Rechenzeit: ", t

"interne Uhr"

>>> ggt(3642431875, 15) = 5Rechenzeit: 160.503182108

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

>>> Zahl 1: 3642431875 Zahl 2: 15 ggt: 5Schleifendurchlaeufe: 242828793

Ausgabe der Ergebnisse

35 Aufgaben

siehe www.inf-schule.de