Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Eigenschaften von Algorithmen Klaus Becker 2008. 2 Algorithmen Zielsetzung: klassische Algorithmen erkunden und dabei zentrale Eigenschaften von Algorithmen.

Ähnliche Präsentationen


Präsentation zum Thema: "Eigenschaften von Algorithmen Klaus Becker 2008. 2 Algorithmen Zielsetzung: klassische Algorithmen erkunden und dabei zentrale Eigenschaften von Algorithmen."—  Präsentation transkript:

1 Eigenschaften von Algorithmen Klaus Becker 2008

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

3 3 Teil 1 Algorithmusbegriff

4 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: /aegypten/zahl2.html Ägyptische Multiplikation Algorithmen werden seit den Anfängen der Mathematik beim Rechnen benutzt. Im "Papyrus Rhind" wird beschrieben, wie in Ägypten Zahlen multipliziert wurden =156

5 5 Aufgabe Finden 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 6 Aufgabe Schreiben Sie eine möglichst präzise Anleitung, nach der jemand, der das Verfahren der Ägypter nicht kennt, zwei Zahlen multiplizieren soll =156

7 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 =156

8 8 Verfahrensbeschreibung Struktogramm Bedingung Anweisung z1 z2 p p := 0 0 z1 > 0 (w) z1 ungerade (w) p := p + z2 12 z1 := z1 / 2 6 z2 := z2 * 2 24 z1 > 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 96 z1 > 0 (w) z1 ungerade (w) p := p + z2 156 z1 := z1 / 2 0 z2 := z2 * z1 > 0 (f) Trace / Ablaufprotokoll =156

9 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 =156

10 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 11 Algorithmen im Alltag ZUTATEN für 5 Portionen: 650g Erdbeeren 150g Zucker 2 Pk Vanillezucker 5 EL Weinbrand 400 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: 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 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 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 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: # Eingabe zahl1 = input("Zahl 1: ") zahl2 = input("Zahl 2: ") # Verarbeitung produkt = 0 while zahl1 > 0: if zahl1 % 2 == 1: produkt = produkt + zahl2 zahl1 = zahl1 / 2 zahl2 = zahl2 * 2 # Ausgabe print "Produkt: ", produkt Struktogramm umgangssprachlich Programm

15 15 Implementierung in Python Es gibt verschiedene Möglichkeiten, einen Algorithmus in Python zu implementieren. # Eingabe zahl1 = input("Zahl 1: ") zahl2 = input("Zahl 2: ") # Verarbeitung produkt = 0 while zahl1 > 0: if zahl1 % 2 == 1: produkt = produkt + zahl2 zahl1 = zahl1 / 2 zahl2 = zahl2 * 2 # Ausgabe print "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: 12 Zahl 2: 13 Produkt: 156 >>> multiplikation(12, 13) 156 Funktions- deklaration

16 16 Implementierung in Scratch

17 17 Aufgaben siehe

18 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* * 12 = (1*2^3 + 1*2^2 + 0*2^1 + 1*2^0) * 12 = 8*12 + 4* *12 = = Der erste Faktor wird implizit in Binärdarstellung umgewandelt. Hierdurch wird die Multiplikation auf Verdoppeln und Halbieren reduziert. Bedingung Anweisung z1 z2 p p := 0 0 z1 > 0 (w) z1 ungerade (w) p := p + z2 12 z1 := z1 / 2 6 z2 := z2 * 2 24 z1 > 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 96 z1 > 0 (w) z1 ungerade (w) p := p + z2 156 z1 := z1 / 2 0 z2 := z2 * z1 > 0 (f)

19 19 Teil 2 Korrektheit von Algorithmen

20 20 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. 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 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 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) } korrekt nicht terminierend vorher: { x = a (nat. Zahl) und y = b (nat. Zahl) } nachher: { x = y = ggT(a, b) }

23 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 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 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) = 4 ggt(7, 13) = 1 ggt(4, 4) = 4 ggt(1, 6) = 1 ggt(6, 18) = 6 Testergebnisse

26 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: 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

27 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 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 29 Teil 3 Effizienz von Algorithmen

30 30 ggT-Berechnung Der ggT von x = 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 31 Effizienz äquivalent effizienter x = ; y = 15 x = ; y = 15 x = ; y = x = 5; y = 5 x = ; y = 15 x = 15; y = 5 x = 5; y = 0 Der ggT von x = und y = 15 soll berechnet werden.

32 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 33 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 > y: x = x - y else: y = y - x return x # Test mit Laufzeitmessung from time import * t1 = clock() z = ggt( , 15) t2 = clock() t = t2 - t1 print "ggt( , 15) = ", z print "Rechenzeit: ", t "interne Uhr" >>> ggt( , 15) = 5 Rechenzeit:

34 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 = 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: Zahl 2: 15 ggt: 5 Schleifendurchlaeufe: Ausgabe der Ergebnisse

35 35 Aufgaben siehe


Herunterladen ppt "Eigenschaften von Algorithmen Klaus Becker 2008. 2 Algorithmen Zielsetzung: klassische Algorithmen erkunden und dabei zentrale Eigenschaften von Algorithmen."

Ähnliche Präsentationen


Google-Anzeigen