eigenschaften von algorithmen klaus becker 2007. 2 algorithmen zielsetzung: klassische algorithmen...

Eigenschaften von Algorithmen

Klaus Becker

2007

2 Algorithmen

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

3 Teil 1

Fallstudie: Ägyptische Multiplikation

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 Multiplikation

Algorithmen 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 Ägyptische Multiplikation

13

6

3

1

12

24

48

96

156

Verfahren:• 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 12∙

= 156

6 Aufgabe

Berechnen Sie mit dem beschriebenen Verfahren folgende Produkte: 16*7 =15*14 = 9*120 =Überprüfen Sie auch, ob die ermittelten Ergebnisse stimmen.

7 Aufgabe

Entwickeln Sie eine algorithmische Beschreibung des Verdopplungs- und Halbierungsverfahren in Struktogrammform.

13

6

3

1

12

24

48

96

156

8 Aufgabe

Warum berechnet dieses merkwürdige Verdopplungs- und Halbierungsverfahren das Produkt von zwei vorgegebenen Zahlen? Versuchen Sie, sich dies klar zu machen.

13

6

3

1

12

24

48

96

156

9

Algorithmus "Ägyptische Multiplikation"

Die ägyptische Multiplikation würde man heute als Algorithmus so beschreiben:

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


Eingabe: x, y

p := 0

SOLANGE x > 0

x ungerade ?ja nein

p := p + y

x := x div 2

y := y * 2

Ausgabe: p

10 Ablaufprotokoll

Bedingung Anweisung x y p

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

13

6

3

1

12

24

48

96

156

Mit Hilfe e. Ablaufprotokolls ("Trace-Tabelle") kann man sich einen ersten Überblick über die Arbeitsweise des Algorithmus verschaffen.


Eingabe: x, y

p := 0

SOLANGE x > 0

x ungerade ?ja nein

p := p + y

x := x div 2

y := y * 2

Ausgabe: p

11 Mathematischer HintergrundBedingung Anweisung x y p


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.

12 Implementierung des Algorithmus

Der Algorithmus "Ägyptische Multiplikation" soll zu Demonstrationszwecken implementiert werden.


Eingabe: x, y

p := 0

SOLANGE x > 0

x ungerade ?ja nein

p := p + y

x := x div 2

y := y * 2

Ausgabe: p

13 Implementierung in PASCAL

Wir implementieren den Algorithmus als Delphi-Konsolenprogramm:

Schritte:Neuen Ordner anlegen<Datei><Neu..><Konsolen-Anwendung>Projekt speichernProgramm eingeben

...var x, y, p: integer;

begin // Eingabe write('x: '); readln(x); write('y: '); readln(y); // Verarbeitung p := 0; while x > 0 do begin if x mod 2 = 1 then p := p + y; x := x div 2; y := y * 2 end; // Ausgabe write('x * y: '); writeln(p); readln;end.

14 Implementierung in PYTHON

Wir implementieren den Algorithmus als Python-Programm:

Starten Sie die Python-Shell. Öffnen Sie ein neues Fenster zur Eingabe des Programms: <File> <New Window>.Geben Sie das Programm (hier als Funktionsdefinition) ein und speichern Sie es unter einem geeigneten Dateinamen ab (z. B. mult_aegypt.py).Rufen Sie vom Programmfenster aus die Python-Shell auf: <Run><Run Module>.Lassen Sie Python geeinete Funktionsaufrufe auswerten.

def mult(x, y): p = 0 while x > 0: if x % 2 == 1: p = p + y x = x / 2 y = y * 2 return p

>>> mult(13, 12)156

Python-Shell mit Programmaufruf

mult1.py

15 Aufgabe

Implementieren Sie den Algorithmus in einer der beiden Sprachen. Ergänzen Sie auch Ausgaben, mit denen man die jeweiligen Zwischenwerte verfolgen kann. In Python geht das ganz einfach (s. u.).

Notieren Sie die Testfälle, die Sie betrachtet haben.

def mult(x, y): p = 0 while x > 0: print x, y, p if x % 2 == 1: p = p + y x = x / 2 y = y * 2 return p

>>> mult(13, 12)13 12 06 24 123 48 121 96 60156

mult2.py

16 Aufgabe

Entwickeln Sie ein analoges Verfahren / einen analogen Algorithmus zum Potenzieren.Tipp: "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."(siehe Wikipedia, Stichwort "schnelles Potenzieren")

17 Teil 2

Korrektheit von Algorithmen

18 Korrektheit

Der Algorithmus "Ägyptische Multiplikation" scheint immer das gewünschte Multiplikationsergebnis zu liefern. Stimmt das auch? Was heißt hier immer?

def mult(x, y): p = 0 while x > 0: if x % 2 == 1: p = p + y x = x / 2 y = y * 2 return p

>>> mult(13, 12)156>>> mult(4, 6)24>>> mult(0, 5)0>>> mult(5, 0)0

19 Spezifikation

Das gewünschte Verhalten des Algorithmus lässt sich wie folgt beschreiben:

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

nachher:{ p = a*b }

Algorithmus

Vorbedingung

Nachbedingung

Eine Spezifikation ist eine vollständige und eindeutige Beschreibung des Ausgangszustands („Zustand vorher“) und des Zielzustands („Zustand nachher“) mit Hilfe einer Vor- und Nachbedingung.

20 Korrektheit eines Algorithmus

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

nachher:{ p = a*b }

Algorithmus

Vorbedingung

Nachbedingung

Korrektheit bezieht sich immer auf vorher festgelegte Anforderungen.

Eine Algorithmus heißt (total) korrekt bzgl. einer Spezifikation, wenn er jeden Ausgangszustand, der die Vorbedingung erfüllt, in einen Zielzustand überführt, der die Nachbedingung erfüllt (und dann anhält).

21

Informelle Korrektheitsüberlegungen

Bedingung Anweisung x y p


Die gezeigten Berechnungsschritte spiegeln sich im Ablaufprotokoll wider. Es fällt auf, dass die Werte der Variablen x, y und p in einem ganz bestimmten Zusammenhang stehen.

13 * 12 =

(6*2+1) * 12 = 6*(2*12) + 12 =

6 * 24 + 12 =

(3*2) * 24 + 12 = 3*(2*24) + 12 =

3 * 48 + 12 =

(1*2+1) * 48 + 12 = 1*(2*48) + (48+12) =

1 * 96 + 60 =

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

0 * 192 + 156

allg.: x * y + p = 13 * 12

Schleifeninvariante

22 Verifikation der Korrektheit

Vor dem ersten Schleifendurchlauf gilt:

x*y+p = a*b (klar, da p = 0)

Wir zeigen, dass der Ausdruck x*y+p nach jedem Schleifendurchlauf seinen Wert nicht verändert. Die Werte der Variablen x, y und p nach einem Schleifendurchlauf nennen wir x', y' und p'. Es gilt:

x ungerade:

p' = p+y 2x'+1 = x bzw. x' = (x-1)/2 y' = 2y

x'*y' + p' = (x-1)/2*(2y) + (p+y) = x*y - y + p + y = x*y + p

x gerade:

p' = p x' = x/2 y' = 2y

x'*y' + p' = (x/2)*(2y) + p = x*y + p

Nach dem letzten Schleifendurchlauf gilt dann:

x*y+p = a*b

Da zudem x=0 gilt, folgt:

p = a*b

Die Korrektheit des Algorithmus lässt sich auch formal zeigen:(siehe auch: http://www.hsg-kl.de/faecher/inf/algorithmus/korrekt/verifikation/index.php)


Eingabe: x, y

p := 0

SOLANGE x > 0

x ungerade ?ja nein

p := p + y

x := x div 2

y := y * 2

Ausgabe: p

23 Aufgabe13 * 12 =

(6*2+1) * 12 = 6*(2*12) + 12 =

6 * 24 + 12 =

(3*2) * 24 + 12 = 3*(2*24) + 12 =

3 * 48 + 12 =

(1*2+1) * 48 + 12 = 1*(2*48) + (48+12) =

1 * 96 + 60 =

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

0 * 192 + 156

allg.: x * y + p = 13 * 12

def mult(x, y): p = 0 while x > 0: print x*y+p if x % 2 == 1: p = p + y x = x / 2 y = y * 2 return p

Schleifeninvariante

Testen Sie mit Hilfe geeigneter Ausgabeanweisungen die Schleifeninvariante.

mult3.py

24 Aufgabe

Testen Sie das unten abgebildete Programm. Was klappt hier nicht?

def mult(x, y): p = 0 while x >= 0: if x % 2 == 1: p = p + y x = x / 2 y = y * 2 print p return p mult4.py

25 Termination

Achtung: Der Algorithmus berechnet zwar die beabsichtigten Ergebnisse, hält aber nicht, um sie zurückzugeben.

def mult(x, y): p = 0 while x >= 0: if x % 2 == 1: p = p + y x = x / 2 y = y * 2 print p return p

>>> mult(7,8)82456565656...

Eine Algorithmus heißt terminierend, wenn er bei jedem möglichen Ausgangszustand in endlich vielen Verarbeitungsschritten zum Ende kommt (und Ausgabedaten als Ergebnisse liefert).

26 Terminationsnachweis

Zum Nachweis der (totalen) Korrektheit eines Algorithmus gehört auch der Nachweis der Termination:

Der Algorithmus terminiert bei natürlichen Zahlen sicher, da x als Eingabewert eine natürliche Zahl erhält und dieser Wert innerhalb der Schleife stets ganzzahlig halbiert wird. Mit jedem Schleifendurchlauf wird der Wert von x demnach kleiner. Nach endlich vielen Schritten muss also der Wert 0 erreicht werden.


Eingabe: x, y

p := 0

SOLANGE x > 0

x ungerade ?ja nein

p := p + y

x := x div 2

y := y * 2

Ausgabe: p

27 Aufgabe

Versuchen Sie, die Korrektheit mit e. geeigneten Invariante zu zeigen bzw. sich die Korrektheit anhand e. typischen Ablaufprotokolls klar zu machen. vorher:x = b (positive rationale Zahl) und y = n (nat. Zahl)

nachher:p = bn

Schnelles Potenzieren

Eingabe: x, y

p := 1

SOLANGE y > 0

y ungerade ?ja nein

p := p * x

y := y div 2

x := x * x

Ausgabe: p

28 Teil 3

Fallstudie: Euklidischer Algorithmus

29

"Wenn CD aber AB nicht misst, und man nimmt bei AB, CD abwechselnd immer das kleinere vom größeren weg, dann muss (schließlich) eine Zahl übrig bleiben, die die vorangehende misst."

aus: Euklid, Die Elemente, Herausgegeben von Clemens Thaer, Wissenschaftliche Buchgesellschaft Darmstadt, VII Buch, §2

siehe auch: http://de.wikipedia.org/wiki/Euklidischer_Algorithmus

Der größte gemeinsame Teiler

Algorithmen werden seit den Anfängen der Mathematik beim Rechnen benutzt. Euklid beschreibt ein Verfahren, mit dem man den größten gemeinsamen Teiler von zwei natürlichen Zahlen bestimmen kann.

ggt(44, 12) =ggt(32, 12) =ggt(20, 12) =ggt(8, 12) =ggt(8, 4) =ggt(4, 4) =ggt(4, 0) =4

30 Wechselwegnahme-Algorithmus

Das Wechselwegnahme-Verfahren lässt sich wie folgt algorithmisch beschreiben.

GGT - Version 1

{x = a; y = b; a,b natürliche Zahlen größer 0}

SOLANGE y > 0

x > yja nein

x := x - y y := y - x

{x = ggT(a,b)}

31 Aufgabe

Überprüfen Sie, ob der gezeigte Algorithmus korrekt ist.

- Fertigen Sie geeignete Ablaufprotokolle per Hand an.- Implementieren Sie den Algorithmus und testen Sie den Algorithmus.- Zeigen Sie die Korrektheit des Algorithmus. Benutzen Sie die folgende Schleifeninvariante: ggt(x, y) = ggt(a, b)

GGT - Version 1


SOLANGE y > 0

x > yja nein

x := x - y y := y - x

{x = ggT(a,b)}

32 Aufgabe

Der größte gemeinsame Teiler lässt sich eventuell aber auch mit anderen Algorithmen berechnen. Überprüfen Sie die folgenden Algorithmen:

GGT - Version 4


SOLANGE y > 0

h := x mod y

x := y

y := h

{x = ggT(a,b)}

GGT - Version 2


WIEDERHOLE BIS x = y

x > yja nein

x := x - y y := y - x

{x = ggT(a,b)}

GGT - Version 3


x <= yja nein

min := x min := y

SOLANGE nicht ((x mod min = 0) oder (y mod min = 0))

min := min - 1

{min = ggT(a,b)}

33 Aufgabe

Welche Unterschiede lassen sich im Verhalten der vorgeschlagenen Algorithmen beobachten?

34 Teil 4

Testen und Laufzeitmessungen

35 TestenDie Überprüfung eines Algorithmus bzw. Programms hinsichtlich Korrektheit kann auf zwei grundsätzlich verschiedene Weisen erfolgen: - Formale Methode (Verifikation): Mittels logischer Herleitungen wird die Einhaltung der Bedingungen an die Zwischen- und Endergebnisse des Algorithmus bzw. Programms nachgewiesen. - Empirische Methode (Testen): Mit bestimmten ausgesuchten Daten, für die das Ergebnis bekannt ist, wird der Algorithmus bzw. das Programm erprobt. Dabei kann lediglich das Vorhandensein von Fehlern entdeckt, nicht jedoch die Fehlerfreiheit nachgewiesen werden.

"Der Methode der Programmverifikation stellen sich in der Praxis große Hindernisse entgegen. Bei umfangreichen Programmen ist ein formaler Korrektheitsbeweis der geschilderten Art i. d. R. nicht möglich. Unsere Beispiele betrafen vergleichsweise wenig umfangreiche mathematische Algorithmen, deren Spezifikation seit Jahrhunderten bekannt ist. In der Praxis besteht das eigentliche Problem jedoch im Entwickeln eines geeigneten Modells (...), und es ist zu prüfen, ob das Modell "auf die Wirklichkeit passt". Erst wenn dies gesichert ist, kann die Verifikation beginnen. In der Praxis ändern sich Spezifikationen laufend, das Modell wird abgewandelt. Daher ist man dort auf die - zugegebenermaßen unvollkommene - Methode des empirischen Testens angewiesen." (aus: R. Baumann: Informatik für die Sekundarstufe II, Band 1. S. 185 ff.)

36 Testdaten

Testdaten müssen sorgfältig gewählt werden. Es reicht in der Regel nicht, nur einige wenige Testfälle durchzuführen.

GGT - Version 2


WIEDERHOLE BIS x = y

x > yja nein

x := x - y y := y - x

{x = ggT(a,b)}

Testfälle:

x = 44; y = 12 4 (ok)

x = 13; y = 5 1 (ok)

x = 24; y = 6 6 (ok)

Die gewählten Testdaten decken hier nicht auf, dass der Algorithmus bei der Eingabe zweier gleicher Zahlen nicht terminiert.

37 Teststrategien

Regeln zur Wahl von Testdaten:

Man wähle sowohl typische als auch untypische Eingabewerte. 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.).

Man sollte auch zufällige Testdaten verwenden, selbst wenn diese nicht sinnvoll erscheinen mögen, denn mit ihnen lassen sich Testlücken aufgrund scheinbarer Selbstverständlichkeiten vermeiden.

Regeln zur Testdurchführung:

Man notiere vor der Durchführung des Testlaufs, welche Ausgabe das Programm laut Spezifikation liefern soll. Man prüfe nicht nur, ob das Programm tut, was es soll, sondern auch, ob es etwas tut, was es nicht soll (z. B.: hat eine Prozedur unerwünschte Nebenwirkungen?)

38 Testen mir Python

>>> 44 12 47 13 14 4 41 9 1

# ggt1Test1.py

def ggt(x, y): while y > 0: if x > y: x = x - y else: y = y - x return x

if __name__ == "__main__": print 44, 12, ggt(44, 12) print 7, 13, ggt(7, 13) print 4, 4, ggt(4, 4) print 1, 9, ggt(1,9)

vorher festgelegte Testfälle

Testergebnisse

39 Testen mir Python

>>> Trying: ggt(44, 12)Expecting: 4okTrying: ggt(7, 13)Expecting: 1okTrying: ggt(4, 4)Expecting: 4ok1 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.

# ggt1Test2.py

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

>>> ggt(44, 12) 4 >>> ggt(7, 13) 1 >>> ggt(4, 4) 4

""" while y > 0: if x > y: x = x - y else: y = y - x return x

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

vorher festgelegte Testfälle mit den

erwarteten Ergebnissen

automatisch erzeugtes

Testprotokoll

40 Systematisches Testen

Anweisungsüberdeckung: Konstruiere die Testfälle so, dass jede Anweisung mindestens einmal ausgeführt wird.

Zweigüberdeckung:Konstruiere die Testfälle so, dass jeder einzelne Zweig im Flussdiagramm mindestens einmal ausgeführt wird.

Pfadüberdeckung:Konstruiere die Testfälle so, dass alle Pfade im Flussdiagramm mindestens einmal ausgeführt werden. Die Anzahl der Scheifendurchläufe wird dabei auf max. 2 begrenzt.

falsch

x := x - y

y > 0?

wahr

Eingabe: x, y

x > y?wahr falsch

y := y - x

Ausgabe: x

41 Systematisches Testen

Testfälle für eine Pfadüberdeckung:

kein Schleifendurchlauf: x = 3; y = 0 3

ein Schleifendurchlauf:x = 4; y = 4 4

zwei Schleifendurchläufe:x = 6; y = 3 (w, f) 3x = 3; y = 6 (f, f) 3

falsch

x := x - y

y > 0?

wahr

Eingabe: x, y

x > y?wahr falsch

y := y - x

Ausgabe: x

42 Aufgabe

Überlegen Sie sich geeignete Testfälle, um den Algorithmus "GGT Version 4" zu testen.

Führen Sie die Tests mit einer geeigneten Testumgebung durch. Protokollieren Sie (ggf. in der Testumgebung integriert) die Ergebnisse.

GGT - Version 4


SOLANGE y > 0

h := x mod y

x := y

y := h

{x = ggT(a,b)}

43 Aufgabe

Überlegen Sie sich geeignete Testfälle, um den Algorithmus "Ägyptische Multiplikation" zu testen.

Führen Sie die Tests mit einer geeigneten Testumgebung durch. Protokollieren Sie (ggf. in der Testumgebung integriert) die Ergebnisse.

falsch

p := p + x

x > 0?

wahr

p := 0

x ungerade?wahr falsch

x := x div 2

y := y * 2

44 Äquivalenz von Algorithmen

Verschiedene Algorithmen, die das gleiches Ein-/Ausgabe-Verhalten zeigen, können sich deutlich im Laufzeitverhalten unterscheiden.

GGT - Version 4


SOLANGE y > 0

h := x mod y

x := y

y := h

{x = ggT(a,b)}

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 Zeit (bzw. mit weniger Speicherplatz) auskommt.

GGT - Version 1


SOLANGE y > 0

x > yja nein

x := x - y y := y - x

{x = ggT(a,b)}

45 Laufzeitmessung mit Python

>>> 4 function calls in 11.452 CPU seconds

...

# ggt1Laufzeit.py


if __name__ == "__main__": import profile profile.run("ggt(768964310867, 34256)")

Performanzanalyse mit dem Profiler

Auszug aus dem Profiler-Protokoll

46 Unterschiedliche Laufzeiten


...

# ggt1Laufzeit.py


if __name__ == "__main__": import profile profile.run ("ggt(768964310867, 34256)")

# ggt4Laufzeit.py

def ggt(x, y): while y > 0: h = x % y x = y y = h return x

if __name__ == "__main__": import profile profile.run ("ggt(768964310867, 34256)")


...

47 Schleifendurchläufe zählen

>>> Zahl 1: 768964310867 Zahl 2: 34256 ggt: 1 Schleifendurchlaeufe: 22447622

# ggt1Schleifendurchlaeufe.py

def ggt(x, y): z = 0 while y > 0: z = z + 1 if x > y: x = x - y else: y = y - x return x, z

if __name__ == "__main__": zahl1 = 768964310867 zahl2 = 34256 (ergebnis, anzahl) = ggt(zahl1, zahl2) print "Zahl 1: ", zahl1, "Zahl 2: ", zahl2, "ggt: ", ergebnis, "Schleifendurchlaeufe: ", anzahl

zusätzlicher Zähler

48

Unterschiedlicher Berechnungsaufwand



def ggt(x, y): z = 0 while y > 0: z = z + 1 if x > y: x = x - y else: y = y - x return x, z

if __name__ == "__main__": zahl1 = 768964310867 zahl2 = 34256 ...


def ggt(x, y): z = 0 while y > 0: z = z + 1 h = x % y x = y y = h return x, z

if __name__ == "__main__": zahl1 = 768964310867 zahl2 = 34256 ...


49 Aufgabe

Untersuchen Sie auch das Verhalten des Algorithmus "ggt - Version 3". Vergleichen Sie diesen Algorithmus mit den beiden anderen ggt-Algorithmen.

50 Aufgabe

Vergleichen Sie die beiden folgenden Algorithmen zum Potenzieren hinsichtlich Laufzeit und Berechnungsaufwand.

def pot(x, n): p = 1 for i in range(0, n): p = p * x return p

def pot(x, y): p = 1 while y > 0: if y % 2 == 1: p = p * x x = x * x y = y / 2 return p

51 Aufgabe

Der folgende Algorithmus überprüft, ob eine natürliche Zahl eine Primzahl ist. Testen Sie diesen Algorithmus. Versuchen Sie auch, effizientere Algorithmen zu entwickeln.

Interessant ist auch das Problem, eine Zahl in ihre Primfaktoren zu zerlegen. Wie könnte ein (effizientes) Verfahren aussehen?

def primzahl(n): prim = True if n == 1: prim = False else: i = 2 while i <= n-1: if n % i == 0: prim = False i = i+1 return prim

52 Aufgabe

Laufzeitmessungen sind auch mit Delphi möglich. Informieren Sie sich hierüber in den folgenden Materialien:

G. Noll: Programmieren mit Delphi. Präsentation (Folie 44). http://informatik.bildung-rp.de/fileadmin/user_upload/informatik.bildung-rp.de/Fortbildung/pps/D-070516-Noll-ProgrammierenMitDelphi.pps

eigenschaften von algorithmen klaus becker 2007. 2 algorithmen zielsetzung: klassische algorithmen...

Documents