Pfiffige Algorithmen - ABZ

Pfiffige Algorithmen 

Mentorierte Arbeit in der Fachdidaktik Informatik 

Autor: Emil Müller 

Betreuer: Prof. Juraj Hromkovic, Giovanni Serafini 

19. Februar 2012

Mentorierte Arbeit Pfiffige Algorithmen Emil Müller 

Inhalt 

Lernziele ...................................................................................................................................... 3 

Ablauf .......................................................................................................................................... 4 

Einleitung .................................................................................................................................... 4 

Binomialkoeffizienten ................................................................................................................. 5 

Pascalsches Dreieck ................................................................................................................ 6 

Neuer Ansatz ......................................................................................................................... 16 

Pfiffige Idee ........................................................................................................................... 18 

Fibonacci-Zahlen berechnen ..................................................................................................... 29 

Intuitiver Ansatz .................................................................................................................... 29 

Iterative Berechnung wie von Hand ..................................................................................... 32 

Raffinierte Iteration .............................................................................................................. 33 

Fazit ....................................................................................................................................... 44 

Literaturverzeichnis .................................................................................................................. 45 

Anhänge ....................................................................................................................................... I 

Fachdidaktik Informatik Seite 2


Fach 

Informatik 

Schultyp 

Mittelstufe 

Alter 

Ab 11. Schuljahr 

Vorkenntnisse Grundlegende Kenntnisse in Java, inkl. 

Objektorientierung. 

Umgang mit Komplexitätsklassen und -Schreibweise 

Binomialkoeffizient ( ) 

 

 

 

 

 

Pascalsches Dreieck. 

Primfaktorzerlegung von Zahlen. 

Binärdarstellung von Zahlen 

Matrix-Multiplikation 

Variablen im mathematischen Sinne 

Bearbeitungsdauer 

ca. 8 Lektionen 

Lernziele 

Leitidee 

In vielen Bereichen der Informatik spielen rekursive Algorithmen eine wichtige Rolle. Sei es 

weil oft mit sehr wenig Code Probleme gelöst werden können, oder weil viele Probleme und 

Fragestellungen auf den ersten Blick nach einem rekursiven Problem aussehen. 

In einigen Bereichen ist aber die Rekursion, obwohl intuitiv sofort einleuchtend, nicht der 

beste Ansatz. In dieser Unterrichtseinheit soll den Schülerinnen und Schülern aufgezeigt 

werden, dass mit relativ wenig Mathematik auf raffinierte Weise schnelle Algorithmen 

entwickelt werden können. 

Lernziele 

- Sie lernen drei verschiedene Algorithmen kennen, um Binomialkoeffizienten ( ) zu 

berechnen. 



- Sie lernen drei verschiedene Algorithmen kennen, um die -te Fibonacci-Zahl zu 

berechnen. 

- Sie lernen, wie die Effizienz von Algorithmen beurteilt werden kann und wie sie in 

Komplexitätsklassen eingeteilt werden können. 

- Sie lernen, wie in Primfaktoren zerlegt werden kann. 

- Sie lernen, wie man algorithmisch auf effiziente Art und Weise grosse Potenzen 

berechnen kann. 

Ablauf 

Diese Unterrichtseinheit ist so konzipiert, dass sie von den Schülerinnen und Schülern 

selbständig erarbeitet werden kann. Aufgrund der relativ komplexen Unterthemen und der 

vielen Aufgaben ist mit einem Aufwand von ca. 8 Lektionen zu rechnen. 

Diese Unterlagen sind so aufgebaut, dass vieles im Text explizit erklärt wird. An den 

wichtigen Stellen werden Sie mit Aufgaben (inklusive detaillierter Lösungen im Anhang) an 

die richtige Idee herangeführt. Versuchen Sie, die Aufgaben selbständig zu lösen und danach 

anhand der Lösungen zu kontrollieren, ob Sie alles verstanden haben. 

Bei den Programmier-Aufgaben kann es nützlich sein, wenn sie zusätzlich zu Ihrer eigenen 

Lösung auch den Code aus der Musterlösung übernehmen und ihn testen. Dies ist deshalb 

hilfreich, weil im weiteren Text jeweils Bezug genommen wird auf den Code aus der 

Musterlösung. 

Einleitung 

Programmieren ist ein kreativer Akt! Die Kreativität offenbart sich dabei jedoch meistens 

nicht auf den ersten Blick. Denn – anders als etwa bei einem Musikstück – ist die erste 

Anforderung an einen Algorithmus, dass er jene Aufgabe zur Zufriedenheit löst, für die er 

erfunden worden ist. Darin lässt sich die Kreativität nicht erkennen. Vergleicht man jedoch 

zwei verschiedene Algorithmen, die das gleiche Problem lösen, können sehr grosse 

Unterschiede zu Tage treten. Diese Unterschiede sind meistens der Kreativität der 

Programmierer zuzuschreiben. Um zu erkennen, muss man jedoch meist ziemlich genau 

hinsehen. 



Ein Anspruch an einen guten Algorithmus kann beispielsweise sein, dass er mit möglichst 

wenig Zeilen Code auskommt. Ein anderer Anspruch kann sein, dass der Algorithmus einen 

gegebenen Input – der mitunter sehr gross sein kann – mit möglichst wenigen 

Rechenschritten verarbeitet. In dieser Unterrichtseinheit wird der zweite Aspekt im 

Vordergrund stehen. 

An zwei Beispielen – Berechnung der Binomialkoeffizienten ( ) und Berechnung des -ten 

Gliedes der Fibonacci-Folge – soll gezeigt werden, wie in der Informatik mathematische 

Resultate und Zusammenhänge äusserst raffiniert eingesetzt werden können. Das Resultat 

werden zwei Algorithmen sein, deren Rechenaufwand um einige Grössenordnungen kleiner 

ist verglichen mit intuitiven Ansätzen. 

Binomialkoeffizienten 

Der Binomialkoeffizient ( ) (lies: „n tief k“) spielt in der Mathematik – und 

überraschenderweise auch im Alltag – eine wichtige Rolle. So gibt es beispielsweise ( ) 

verschiedene Möglichkeiten einen Lottoschein auszufüllen, wenn 6 Kugeln aus 45 gezogen 

werden. Beim Berechnen von ( ) hat das Glied den Koeffizienten ( ). (Daher 

kommt übrigens auch sein Name.) Oder es gibt zwischen 0 und 1‘000‘000 genau ( ) Zahlen, 

in denen genau 3 Mal die Ziffer 7 vorkommt. 

Allgemein spielt der Binomialkoeffizient vor allem beim Berechnen von 

Wahrscheinlichkeiten und in der Statistik eine sehr wichtige Rolle. Deshalb ist die 

Entwicklung eines Algorithmus, der mit möglichst wenig Rechenaufwand beispielsweise 

( ) berechnen kann, sehr wünschenswert. Der Wert von ( ) ist übrigens eine 

unsäglich grosse Zahl, die auch von den besten Taschenrechnern im Moment nicht 

berechnet werden kann. Sie hat sage und schreibe 1116 Stellen. An diesem Beispiel wird 

ersichtlich, weshalb es sehr sinnvoll ist, einen Algorithmus zu haben, der raffiniert genug ist, 

mit derart grossen Zahlen rechnen zu können. 

Auf dem Weg zu einem schnellen Algorithmus, setzen wir als erstes die naheliegende Idee 

um, die Sie aus dem Mathematik-Unterricht kennen. 



Pascalsches Dreieck 

Im Mathematik-Unterricht haben Sie gelernt, wie man beispielsweise ( 

) berechnet. 

Diese Summe besteht aus den Termen und . Jeder Term wird 

noch mit einem 

Koeffizienten multipliziert, 

den man aus dem 

Pascalschen Dreieck abliest. 

Dabei gilt: Für die 

Berechnung von ( ) 

liest man die Koeffizienten 

in der -ten Zeile des 

Pascalschen Dreiecks ab. 

Tab. 1 

1 

1 1 

1 2 1 

1 3 3 1 

1 4 6 4 1 

1 5 10 10 5 1 

1 6 15 20 15 6 1 

Will man also ( 

ist. Dabei gilt: 

) berechnen, benötigt man die Koeffizienten aus jener Zeile, wo 

- 1. Eintrag: ( ) 

- 2. Eintrag: ( ) 

- 3. Eintrag: ( ) 

- usw. 

Trägt man in der obigen Tabelle anstatt der Zahlen die Symbole ein, tritt das Muster zu Tage, 

das uns im nächsten Abschnitt helfen wird, einen Algorithmus zu entwickeln. 

( ) 1 

( ) ( ) 2 

( ) ( ) ( ) 3 

( ) ( ) ( ) ( ) 4 

( ) ( ) ( ) ( ) ( ) 5 

( ) ( ) ( ) ( ) ( ) ( ) 6 

Tab. 2 

( ) ( ) ( ) ( ) ( ) ( ) ( ) 



Algorithmische Vorüberlegungen 

Will man einen Algorithmus schreiben, der beliebige Binomialkoeffizienten berechnet, sind 

einige Vorüberlegungen nötig. Insbesondere wollen wir die Tatsache ausnützen, dass ein 

Eintrag im Pascalschen Dreieck die Summe der zwei darüber liegenden Einträge ist. 

Aus Tab. 2 wird ersichtlich, dass beispielsweise für die Berechnung von ( ) die beiden 

Einträge ( ) und ( ) herangezogen werden müssen. Für die Berechnung von ( ) wiederum 

werden ( ) und ( ) benötigt. Und so weiter. 

Verallgemeinert man diese Beobachtung für die Berechnung von ( ), so werden dazu die 

beiden Einträge ( ) und ( ) in der Zeile darüber benötigt. Also Formel bedeutet 

dies: 

( ) ( ) ( ) 

Mit anderen Worten: Anstatt ( ) direkt zu berechnen, berechnen wir die Summe von 

( ) ( ). Allerdings um beispielsweise ( ) zu berechnen, benötigen wir 

( ) ( ). Und so weiter. Sollte zu irgend einem Zeitpunkt ( ) oder ( ) berechnet 

werden, stoppt die Berechnungskette, denn ( ) und ( ) . Mit diesen Überlegungen 

lässt sich ein rekursiver Algorithmus entwickeln. Im Pseudocode sieht sie so aus: 

BinKoeffizientRek(n,k){ 

Falls oder 

return 1 

sonst 

return BinKoeffizientRek(n-1,k-1)+BinKoeffizientRek(n-1,k) 

} 

Aufgabe 1 Schreiben Sie eine Java-Klasse BinKoeff, die eine main-Methode enthält 

und eine Methode int binKoeffRek(int n, int k). Letztere soll den 

Binomialkoeffizienten ( ) rekursiv berechnen, wie oben beschrieben. 

Aufgabe 2 

Testen Sie Ihre Klasse mit den Beispielen 

( ) ( ) ( ) ( ) ( ) ( ) ( ) auf Ihre Richtigkeit. 



Ist das ein guter Algorithmus? 

Für die Beurteilung der Güte des Algorithmus‘ ist entscheidend, wie viele 

Berechnungsschritte er durchführen muss, um ( ) zu berechnen. Aufgrund seiner 

rekursiven Struktur ist deshalb massgebend, wie oft sich die Funktion selbst aufruft. 

Betrachtet man den Algorithmus, erkennt man, dass sich die Funktion zwei Mal selbst 

wieder aufruft, ausser wenn oder . Da letzterer Fall jedoch nicht so oft auftritt, 

ist das zweimalige Aufrufen von sich selbst der wichtige Aspekt. 

Das Zählen der Funktionsaufrufe für die Berechnung von ( ) wird stark erleichtert, wenn 

man sich den Berechnungsbaum aufzeichnet. 

Für die Berechnung von beispielsweise ( ), startet der Algorithmus mit den Werten 

und . Danach wird bei jedem Aufruf um eins verringert und die Funktion selbst zwei 

Mal aufgerufen. Dies wird so lange wiederholt, bis entweder oder ist. 

Insgesamt wird also auf Stufen die Funktion 2 Mal - total also in der Grössenordnung von 

Mal - aufgerufen. Diese grosse Zahl von Funktionsaufrufen rührt daher, dass die Funktion 

mehrere Male mit den gleichen Werten aufgerufen wird – viele Werte also mehrfach 



berechnet werden. Im Bild ist der Wert ( ) hervorgehoben. Er wird schon für die 

vergleichsweise kurze Berechnung von ( ) drei Mal berechnet. 

Für grosse 

bedeutet dies, dass für die Berechnung von ( ) die Funktion unheimlich oft 

aufgerufen wird und somit enorm viele Berechnungsschritte nötig sind. 

Berechnung des Pascalschen Dreiecks 

Müssten Sie selbst - ohne Hilfe eines Computers - einen bestimmten Binomialkoeffizienten 

berechnen, würden Sie sicher anders vorgehen, als oben beschrieben. Sie würden von oben 

nach unten das Pascalsche Dreieck nach und nach berechnen. Dabei schreiben Sie die bereits 

berechneten Werte in eine Tabelle und ziehen diese für die nächsten Berechnungen wieder 

heran. 

Diese Idee wollen wir nun in einen Algorithmus übersetzen und überprüfen, ob wir 

gegenüber dem rekursiven Ansatz eine Verbesserung erreichen können. 

Dazu benötigen wir als erstes einen zweidimensionalen Array, der das Pascalsche Dreieck 

repräsentiert. Dabei soll gelten, dass die erste Zeile die Länge 1 hat, die zweite Zeile die 

Länge 2, usw. Dieser Array soll in zwei verschachtelten Schleifen mit den entsprechenden 

Werten gefüllt werden. Auch bei diesen Berechnungen nutzen wir die Eigenschaft des 

Pascalschen Dreiecks, dass jeder Wert – ausser den Einträgen am Rand – der Summe der 

zwei darüber liegenden Werte entspricht. 

Nach den Berechnungen hat dieser zweidimensionale Array die Form: 

1 pascal[0] 

1 1 pascal[1] 

1 2 1 pascal[2] 

1 3 3 1 pascal[3] 

1 4 6 4 1 pascal[4] 

1 5 10 10 5 1 pascal[5] 

1 6 15 20 15 6 1 pascal[6] 

1 7 21 35 35 21 7 1 pascal[7] 

1 8 28 56 70 56 28 8 1 pascal[8] 

1 9 36 84 126 126 84 36 9 1 pascal[9] 

1 10 45 120 210 252 210 120 45 10 1 pascal[10] 

Tab. 3 

Dabei entspricht die eingekreiste Zelle pascal[8][3] dem Wert des Binomialkoeffizienten 

( ). Will man nun damit eine Funktion int binKoeffPascal(int n, int k) entwickeln, 



die den Binomialkoeffizienten mittels des Pascalschen Dreiecks ausrechnet, so muss in 

einem ersten Schritt der zweidimensionale Array pascal[][] mit der entsprechenden Länge 

(entspricht dem Wert von ) initialisiert werden. Die Längen der Arrays für die einzelnen 

Zeilen bleiben dabei vorerst noch unbestimmt. Danach müssen in einer Schleife die Längen 

der Zeilen festgelegt und in jeder Zeile die Rand-Zellen mit 1 beschrieben werden. 

Schliesslich folgen die verschachtelten Schleifen – eine für die Zeilen, eine für die Spalten -, 

die die Werte berechnen und in den Array schreiben. 

Innerhalb der Schleife soll der Algorithmus so funktionieren, dass er für die Berechnung 

eines Eintrags pascal[i][j] immer auf die zwei Einträge pascal[i-1][j-1] und 

pascal[i-1][j] in der Zeile darüber zugreifen kann und es dabei zu keinen Array-Index- 

Problemen kommt. Dazu braucht es jedoch noch eine Überlegung in Bezug auf die 

möglichen Werte der Schleifenvariablen i (Zeile) und j (Spalte). Denn darf nicht 0 sein, 

über der Zeile 0 keine Zeile mehr existiert. Zudem darf auch nicht 1 sein, da beide Einträge 

in der ersten Zeile Rand-Einträge sind und nicht mittels der darüber liegenden Werte 

berechnet werden können. Für j gilt, dass es ebenfalls nicht 0 sein darf, da in der Zeile 

darüber kein Eintrag mit dem Index -1 existiert. Auch am rechten Rand gibt es eine 

Einschränkung für j. Dort muss der Wert für j strikt kleiner bleiben als der Zeilenindex i. 

Andernfalls würde der Algorithmus für die Berechnung von pascal[i][i] versuchen, auf 

den Eintrag pascal[i-1][i] zuzugreifen, der ebenfalls nicht existiert. Zusammengefasst gilt 

also: 

Werte für den Zeilenindex : bis 

Werte für den Spaltenindex : bis 

Damit können wir nun den Algorithmus als Pseudocode festhalten: 

int binKoeffPascal(int n, int k){ 

intialisiere den int-Array pascal[] mit Länge n+1 //Zeilen von 0 bis n 

for i=0 to n 

intialisiere pascal[i] mit Länge i+1 

pascal[i][0]


Aufgabe 3 

Schreiben Sie in ihrer Klasse BinKoeff, eine Methode public static int 

binKoeffPascal(int n, int k), die den Binomialkoeffizienten ( ) wie oben 

beschrieben berechnet und zurückgibt. 

Ist dieser Algorithmus schneller? 

Schon im letzten Abschnitt haben wir uns gefragt, wie man beurteilen kann, wie schnell ein 

Algorithmus seine Aufgabe erledigt. Dies wollen wir auch für diesen Algorithmus 

durchführen. Doch zuerst benötigen wir einige Werkzeuge, die uns auch später helfen 

werden, über die Güte von Algorithmen zu sprechen. 

Bei der Beurteilung eines Algorithmus‘ interessiert und uns hier vor allem die Frage, wie viele 

Berechnungsschritte durchgeführt werden müssen, um das Resultat zu erhalten. Und zwar 

soll dies nicht für jeden einzelnen Input angegeben werden, sondern ein Algorithmus so zu 

klassifizieren, dass man in Abhängigkeit von der Grösse des Inputs – in unserem Fall – 

angeben kann, wie viele Schritte der Algorithmus schlimmstenfalls benötigt. 

Wir werden uns dies in folgenden Schritten überlegen: 

1. Schritte in einem konkreten Beispiel zählen 

2. Schritte im allgemeinen Fall zählen. 

3. Schreibweise entwickeln für die Klassifizierung 

4. Schlussfolgerungen ziehen. 

1. Schritte in einem konkreten Beispiel zählen 

Beim Zählen von Schritten, die ein Algorithmus durchführt ist etwas Vorsicht geboten. Denn 

die Frage dabei ist, was ein Schritt ist. Ist es eine Zeile Code? Ist es die Durchführung einer 

mathematischen Operation? Kann es auch ein Vergleich der Werte zweier Variablen oder gar 

die Zuweisung eines Wertes zu einer Variablen sein? Eine einfache Antwort auf diese Fragen 

gibt es nicht. Sicher ist es falsch, eine Code-Zeile immer nur als einen Schritt zu zählen. Denn 

in einer einzigen Zeile lassen sich mehrere Berechnungsschritte zusammenfassen. Darüber 

hinaus hängt die Antwort auf die obigen Fragen jedoch vom behandelten Problem ab. So ist 

es beispielsweise zulässig, eine mathematische Operation als einen Schritt zu zählen, so 

lange die Zahlen, die in die Berechnung involviert sind, relativ klein sind. Wachsen diese 

jedoch an, kann eine Multiplikation zweier Zahlen plötzlich mit viel mehr als nur einem 

einzigen Schritt zu Buche schlagen, weil im Register viele Operationen durchzuführen sind, 



bis die Multiplikation bewerkstelligt ist. Auch der Vergleich der Werte zweier Variablen oder 

die Zuweisung eines Wertes zu einer Variablen kann als ein Schritt gewertet werden. Denn 

immerhin muss der Rechner etwas tun, um im Register einen Wert abzuspeichern oder zwei 

Werte für einen Vergleich aus dem Register auszulesen. 

In diesem Abschnitt werden wir die Schritte zählen, die für die Berechnung von ( ) nötig 

sind. Dabei treten keine ganz grossen Zahlen auf. Aus diesem Grund können wir die Addition 

als einen einzigen Schritt zählen. Variablen-Vergleiche lassen wir ausser Betracht. 

Wir überlegen uns, wie viele Rechenschritte nötig sind, um mithilfe des Pascalschen Dreiecks 

die Zahl ( ) zu berechnen. Offensichtlich ist in diesem Fall und . Für die 

Initialisierung des zweidimensionalen Arrays durchläuft der Algorithmus eine Schleife Mal 

und führt in jedem Durchgang 3 Schritte (Initialisierung und zwei Additionen) aus. Diese 

erste Schleife benötigt deshalb Schritte – im konkreten Fall 18 Schritte. 

Interessanter wird die Betrachtung der zwei verschachtelten Schleifen. Dort läuft die 

Variable der äusseren Schleife die Werte von bis . Für jeden Durchgang durchläuft die 

Variable der inneren Schleife die Werte von 1 bis . Und in jedem Durchgang wird eine 

Addition durchgeführt. 

Um die Anzahl Schritte zu zählen, halten wir in einer Tabelle fest, wie gross jeweils ist und 

wie viele Werte die Variable durchlaufen muss. Am Schluss lassen sich die Durchgänge 

addieren. 

2 1 

3 2 

4 3 

5 4 

6 5 

Total 

Tab. 4 

Anzahl Durchläufe der inneren Schleife 

Zählt man alles zusammen benötigt der Algorithmus 18+15=33 Schritte, um ( ) zu 

berechnen. 



Aufgabe 4 

Bestimmen Sie mit dem obigen Verfahren, wie viele Schritte nötig sind, um 

( ) ( ) ( ) und ( ) zu berechnen. 

2. Schritte im allgemeinen Fall zählen 

Will man die Schritte im allgemeinen Fall – für ( ) – zählen, führen wir die Tabelle von oben 

fort und versuchen, die Schritte für ein allgemeines 

zu zählen. 

2 1 

3 2 

4 3 

5 4 

6 5 

7 6 

… 

Anzahl Durchläufe der inneren Schleife 

Tab. 5 

Aus der Tabelle wird ersichtlich, dass in den verschachtelten Schleifen insgesamt 

∑ 

Schritte nötig sind. Aus dem Mathematik-Unterricht wissen Sie, dass diese Summe als das 

Produkt 

∑ 

( ) 

dargestellt werden kann. 

Zu diesen Berechnungen kommen noch die 

wir insgesamt für die maximale Anzahl Schritte 

Schritte für die Initialisierung. Damit haben 

( ), die zur Berechnung von ( ) nötig 

sind, folgende Formel: 

( ) 

( ) 



3. Schreibweise entwickeln 

Wir betrachten, wie sich diese Anzahlen für wachsende 

entwickeln. 

Betrachtet man den Funktionsterm von 

6 33 

7 42 

8 52 

9 63 

10 75 

20 250 

30 525 

50 1375 

75 3000 

100 5250 

( ) 

1000 502500 

10000 50025000 

100000 5000250000 

Tab. 6 

( ), fällt auf, dass er ein Polynom zweiten 

Grades in ist. Aus diesem Grund versuchen wir nun, eine Beziehung zwischen ( ) und 

herzustellen. 

Aufgabe 5 

Vergleichen Sie die Werte aus Tab. 6 mit den entsprechenden Werten für 

und untersuchen Sie, ob der Wert 

( ) 

für konvergiert? Und wenn ja, 

gegen welchen Wert? 

Wenn Sie die Aufgabe 5 richtig bearbeitet haben, sollten Sie herausgefunden haben, dass die 

folgende Gesetzmässigkeit gilt: 

( ) 

Das bedeutet, dass die Funktion ( ) für grosse gegen den Wert konvergiert. 

Anders gesagt: ( ) kann nicht wesentlich schneller wachsen als , wenn grosse 

Werte annimmt. 

Mit diesen Überlegungen können wir nun ein Qualitäts-Mass für unseren Algorithmus 

angeben. Für kleine liefert er in kürzester Zeit das richtige Resultat. Für grosse benötigt 

er jedoch ziemlich viele Rechenschritte: Erhöht man um den Faktor 2, so wächst die Anzahl 

Berechnungsschritt ungefähr um den Faktor 4. Erhöht man um den Faktor 3, wächsts 

( ) um den Faktor 9. Und so weiter. 



Mit anderen Worten: 

( ) wächst ungefähr quadratisch in . 

Damit ist unser Algorithmus klassifiziert: Er benötigt mit steigendem ungefähr Schritte 

für die die Berechnung von ( ). Erstaunlicherweise ist unser Algorithmus nur von 

abhängig. Wie gross 

ist, spielt für die Anzahl Berechnungsschritte überhaupt keine Rolle. 

Die Funktion ( ) gehört demnach zu einer bestimmten Klasse von Funktionen, die 

ungefähr quadratisch mit dem Input wachsen. In der Mathematik und in der Informatik 

haben solche Klassen von Funktionen einen eigenen Namen. 

Man schreibt: 

( ) ( ) 

Dabei ist 

( ) so definiert, wie man es nach den obigen Überlegungen erwartet. 

Definition (Landau Symbol ) 

( ) 

( ) ( ) 

( ) ( ( )) 

( ( )) ( ) 

( ) 

( ( )) { | ( ) 

( ) | } 

Für jede Funktion ( ) ( ( )) sagen wir, dass mit wachsendem asymptotisch nicht 

schneller wächst als . 

Als Bild: 



Aufgabe 6 Wie muss die Konstante gewählt werden, damit die Funktion 

gegen 

konvergiert? 

Aufgabe 7 Gilt ( ) ( )? (Begründen Sie Ihre Antwort.) 

Aufgabe 8 In welcher Komplexitätsklasse liegt ? (Begründen 

Sie Ihre Antwort.) 

Aufgabe 9 Liegt in ( ) Falls ja, geben Sie die Konstante an. 

Aufgabe 10 Liegt in ( )? Falls ja, geben Sie die Konstante an. 

Aufgabe 11 Liegt in ( ( ))? Falls ja, geben sie die Konstante an. 

Aufgabe 12 Geben Sie an, zu welcher Komplexitätsklasse 

gehört, der die Binomialkoeffizienten rekursiv berechnet. 

( ( )) der Algorithmus 

4. Schlussfolgerung 

Sowohl der binKoeffRek- als auch der binKoeffPascal-Algorithmus sind nur für kleine 

wirklich brauchbar. Falls sehr gross wird, müssen exponentiell oder quadratisch viele 

Rechenschritte gemacht werden. Die Frage ist also: Gelingt es uns, einen anderen 

Algorithmus zu finden, der für grosse merklich weniger Berechnungen machen muss? 

Neuer Ansatz 

Wie Sie bestimmt aus dem Mathematik-Unterricht wissen, lassen sich die 

Binomialkoeffizienten auch anders als mit dem Pascalschen Dreieck berechnen. Es gilt: 

( ) 

( ) 

So ist beispielsweise ( ) . 

Dies ermöglicht einen neuen Ansatz für die algorithmische Berechnung – und zwar iterativ 

mit Schleifen. Wir betrachten den Term etwas genauer: 



( ) 

( ) ( ) ( ) ( ) ( ) 

⏟ ( ) 

( ⏟ ) ( ) 

( ) 

Man erkennt, dass der Term ( 

man mit ( 

) kürzen. 

) sowohl im Zähler als auch im Nenner steht. Also kann 

Es bleibt: 

( ) 

⏞ 

( ) ( ) ( ) 

( ) 

Dieser Bruch enthält im Zähler und im Nenner je Faktoren, von denen jeder um eins 

kleiner ist als sein Vorgänger/Nachfolger. Im Zähler hat der grösste Faktor den Wert im 

Nenner hat der grösste Faktor den Wert . 

In unserem Algorithmus benötigen wir deshalb eine Schleife über 

Durchgang um 1 erhöht werden. 

Werte, die bei jedem 

Im Pseudocode sieht das so aus: 

binKoeffIterativ(n,k){ 

i=0; 

ZwResultat =1; 

Solange i


durchlaufen werden. Zwar werden bei jedem Schleifendurchgang zwei Rechenschritte 

durchgeführt. Aber trotzdem: Die maximale Anzahl Schritte ( ) wächst linear in . 

Es gilt für den binKoeffIterativ-Algorithmus: 

( ) ( ) 

Wenn beispielsweise 

, benötigt die Berechnung mit dem Pascalschen Dreieck 

ungefähr Schritte. Der Iterative Ansatz dagegen kommt mit maximal 200 

Schritten aus. Dieser Ansatz ist also sehr viel effizienter als der erste. 

Pfiffige Idee 

Wie in der Einleitung schon bemerkt, werden Binomialkoeffizienten für grosse schnell 

sehr, sehr gross. Deshalb ist einigermassen erstaunlich, dass wir einen Algorithmus gefunden 

haben, dessen Anzahl Berechnungen nur mit der linear in wächst. Es kommt aber noch 

besser! In diesem Abschnitt werden wir einen Algorithmus entwickeln, der noch schneller 

ist! Doch dazu sind jedoch erst einige mathematische Überlegungen notwendig. 

Fakultät in Primfaktoren zerlegen 

Zur Vorbereitung überlegen wir uns, wie die Primfaktorzerlegung einer Fakultät 

Betrachten wir zuerst einige Beispiele: 

aussieht. 

Offensichtlich gibt es bei der Primfaktorzerlegung ein Muster! 

Aufgabe 14 Bei welchem wird in der Primfaktorzerlegung von zum ersten Mal 

stehen? 

Aufgabe 15 Bei welchem 

erhöhen? 

wird sich der Exponent von 3 zum nächsten Mal 

Aufgabe 16 Wie viele Faktoren von 

Aufgabe 17 Wie viele Faktoren von 

sind durch 2 teilbar? 

sind durch 4 teilbar? 



Aufgabe 18 Wie viele Faktoren von 101! sind durch 2 teilbar? 

Aufgabe 19 Wie viele Faktoren von 101! sind durch 31 teilbar? 

Die Resultate aus den Aufgaben wollen wir nun systematisch untersuchen. Dazu betrachten 

wir . 

Zuerst überlegen wir uns, mit welcher Potenz die Zahl 2 in der Primfaktorzerlegung von 

vorkommt. In den Aufgaben haben Sie festgestellt, dass jede 2. Zahl die kleiner als 11 ist 

durch 2 teilbar ist. Zudem ist jede 4. durch 4 teilbar, jede 8. durch 8. 

Dies wird ersichtlich, wenn man die Faktoren der Fakultät in Primfaktoren zerlegt: 

⏟ ⏟ ⏟ ⏟ ⏟ 

Es gilt: 

- ⌊ ⌋ Zahlen sind durch 2 teilbar (rot). (Dabei bezeichnet die auf die nächste 

ganze Zahl abgerundete rationale (oder reelle) Zahl . Diese Klammer heisst auch 

Gauss-Klammer) In der Primfaktorzerlegung muss also mindestens 

vorkommen. 

- ⌊ ⌋ Zahlen sind zudem durch 4 teilbar (grün). Jede dieser 2 Zahlen ist also nicht 

nur durch 2, sondern auch durch 4 teilbar. Die Teilbarkeit durch 2 haben wir bereits 

berücksichtigt. Also fehlt für jede dieser beiden Zahlen noch ein Faktor 2, den wir 

noch nicht berücksichtigt haben. Damit muss in der Primfaktorzerlegung mindestens 

stehen. 

- ⌊ ⌋ Zahl ist zudem durch 8 teilbar (blau). Damit haben wir . 

Resultat: In der Primfaktorzerlegung von kommt der Faktor vor. 

Aufgabe 20 Mit welcher Potenz kommen die Zahlen 3,5,7 und 11 in der 

Primfaktorzerlegung von vor? Notiere danach die Primfaktorzerlegung von 



Was Sie eben entdeckt haben, ist in der Mathematik bekannt als 

Satz von Legendre 

∏ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ 

Mit dieser Idee werden wir nun einen besseren Algorithmus zur Berechnung der 

Binomialkoeffizienten entwickeln. Wir werden versuchen die Fakultäten in 

Satz von Legendre zu berechnen. 

( ) 

mit dem 

Dazu werden wir zwei zusätzliche Dinge benötigen: 

1. Wir brauchen eine Liste der Primzahlen, die kleiner als sind, um danach die 

Potenzen dieser Primzahlen zu berechnen. 

2. Eine Funktion, die für ein gegebenes und eine Primzahl den Exponenten von in 

der Primfaktorzerlegung von berechnet. 

Liste der Primzahlen erzeugen 

Primzahlen zu finden, ist auf den ersten Blick keine einfache Sache, weil sie nicht regelmässig 

auftreten. Allerdings hat der griechische Gelehrte Eratosthenes von Kyrene ca. 275 v. Chr. 

eine Methode gefunden, wie man systematisch eine Liste von Primzahlen bis zu einer 

bestimmten Maximalgrösse erzeugen kann. 

Die Idee ist: 

- Man schreibt alle Zahlen von 2 bis in eine Liste 

- Dann beginnt man mit der ersten Zahl in der Liste (also 2), lässt diese stehen und 

streicht alle Vielfachen. 

- Danach geht man zur nächsten Zahl, die noch in der Liste steht, lässt diese stehen 

und streicht alle Vielfachen dieser Zahl 

- usw. 



Am Ende liefert dieses Verfahren alle Primzahlen, die kleiner als 

public static int[] getPrimes(int n) { 

int[] allNumbers = new int[n + 1]; 

// Alle Zahlen in eine Liste schreiben 

for (int i = 2; i


Für den 2. Punkt werden wir eine eigene Funktion int calculatePower(int p, int n) 

schreiben. Der Exponent von in der Primfaktorzerlegung von wird berechnet mit der 

Summe ( ) ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ . 

Demnach würde der Algorithmus so aussehen: 

calculatePowert(int p, int n){ 

i=1 

resultat=0 

solange i


abzurunden, und Math.pow(double b, double e), um die Potenz 

berechnen.) 

zu 

Optimierung 

Im Prinzip hätten wir jetzt alle Hilfsmittel beisammen, um den Binomialkoeffizienten mit 

dem Satz von Legendre zu berechnen. Ein Algorithmus könnte so aussehen: 

binKoeffLegendre(int n, int k){ 

erzeuge Liste PRIMES der Primazahlen, die kleiner als n sind. 

berechne ZAEHLER=n! mit PRIMES 

berechne NENER=k!*(n-k)! mit Primzahlen


Die Funktion sieht so aus: 

/** 

* Berechnet die Primfaktorzerlegung von k!. Diese Methode erzeugt einen 

* Array mit der gleichen Länge wie primes. Dort werden die 

* Exponenten der Primzahlen in der Primfaktorzerlegung von k! nach dem 

* Muster res[i]=Exponent von primes[i] in der Primfaktorzerlegung von k! 

* gespeichert. 

* 

* @param primes Array, der die Primzahlen < n enthält. 

* @param k Zahl, zu deren Fakultät die Primfaktorzerlegung berechnet wird. 

* 

*/ 

public static int[] primeFakt(int[] primes, int k) { 

int[] res = new int[primes.length]; 

// Nur Primzahlen beachten, die kleiner als k sind. 

for (int i = 0; primes[i]


Zeit in Sekunden 

n 

k 

Anz. 

Stellen rekursiv Pasc. Dreieck iterativ Legendre 

10 5 3 0.00184898 1.22E-04 3.62E-04 1.11E-04 

20 10 6 0.04593385 1.19E-04 3.74E-04 1.15E-04 

50 25 15 > 600 0.00236871 7.65E-04 1.79E-04 

100 50 30 0.00302797 1.07E-03 2.48E-04 

200 100 59 0.0064442 2.39E-03 6.93E-04 

500 250 150 0.05917525 4.91E-03 4.72E-04 

1000 500 300 0.27922667 4.13E-03 5.62E-04 

2000 1000 601 2.18885341 9.78E-03 1.02E-03 

5000 2500 1504 

zu wenig 

Speicher 

3.30E-02 2.70E-03 

10000 5000 3009 9.42E-02 5.25E-03 

20000 10000 6019 2.91E-01 1.05E-02 

50000 25000 15050 1.64E+00 4.71E-02 

100000 50000 30101 6.49E+00 1.67E-01 

200000 100000 60204 2.48E+01 6.73E-01 

500000 250000 150513 1.56E+02 3.42E+00 

1000000 500000 301027 6.31E+02 1.34E+01 

Tab. 7 

Für kleine Werte von und sind die Unterschiede sehr gering und spielen in der Praxis 

keine Rolle. Doch schon bei 

Minuten rechnet. Bei 

versagt der rekursive Algorithmus, weil er über zehn 

versagt auch die Berechnung mit dem Pascalschen Dreieck, 

weil der Speicherplatz (1.5 GB!) nicht ausreicht, um sämtliche Einträge im Pascalschen 

Dreieck festzuhalten. 

Betrachtet man die Einträge für 

, bei denen die Resultate mehrere Tausend 

Stellen aufweisen, so werden auch die Unterschiede zwischen dem iterativen und dem 

Legendre-Algorithmus eklatant. Während der Legendre-Algorithmus deutlich weniger als 

eine Sekunde rechnet, benötigt der iterative Ansatz schon mehrere Sekunden. Am 

deutlichsten zu Tage treten die Unterschiede in der letzten Zeile für ( 

). Das 

Resultat ist eine Zahl mit sagenhaften 301027 Stellen. Der iterative Algorithmus rechnet hier 

mehr als zehn Minuten (!) – für Computer eine Ewigkeit. Der Legendre-Algorithmus dagegen 

hat das unglaublich grosse Resultat nach 13 Sekunden berechnet. 

Grafisch dargestellt: 


Sekunden 


1000 

100 

10 

1 

0.1 

0.01 

0.001 

0.0001 

rekursiv 

Pasc. Dreieck 

iterativ 

Legendre 

n 

Tab. 8 

In dieser Darstellung ist zu beachten, dass die vertikale Achse eine logarithmische Skala 

aufweist. Das bedeutet: Ein Unterschied von einem Linienabstand entspricht einem 

Unterschied von Faktor 10. Am rechten Rand der Darstellung (für 

) ist 

demnach der Legendre-Algorithmus fast 100 mal schneller als der iterative Algorithmus. 

Offensichtlich wächst der Zeitaufwand des iterativen Algorithmus‘ ungefähr linear zu , 

dessen Grössen auf der horizontalen Achse ebenfalls logarithmisch aufgetragen sind. Die 

Frage, die uns zum Abschluss dieses Kapitels beschäftigt, ist: 

Wie schnell ist der Legendre-Algorithmus? 

Der Algorithmus besteht im Wesentlichen aus drei Teilen: 

1. Liste erzeugen mit allen Primzahlen . 

2. und ( ) in Primfaktoren zerlegen. 

3. Das Resultat als Produkt von Primfaktoren berechnen. 

Der Einfachheit halber lassen wir die Erzeugung der Primzahlliste mal beiseite und nehmen 

an, wir hätten irgendwo eine grosse Liste mit Primzahlen zur Verfügung, auf die wir ohne 

grossen Rechenaufwand zurückgreifen können. Man kann sich auch vorstellen, dass diese 

Liste ein Mal erzeugt und abgespeichert wird, so dass wir später immer wieder darauf 

zurückgreifen können. 

Die Frage ist also, wie viele Berechnungen werden für die Schritte 2 und 3 im schlechtesten 

Fall benötigt? 



Primfaktoren berechnen 

Bei der Zerlegung einer Fakultät in ihre Primfaktoren ist die entscheidende Grösse die Liste 

mit den Primzahlen. Deshalb müssen wir uns zuerst überlegen, wie viele Primzahlen es bei 

einem gegebenen geben kann, so dass ist. Leider ist diese Überlegung hier nicht 

möglich, weil die Primzahlen ziemlich widerspenstige mathematische Objekte sind, die sehr 

unregelmässig verteilt sind. Es ist deshalb bis heute nicht gelungen, eine Funktion ( ) 

konkret anzugeben, die einem die Anzahl Primzahlen liefert, die kleiner als sind. Allerdings 

haben sich zum Glück einige der grössten Mathematiker der Geschichte (Carl Friedrich 

Gauss, Adrien-Marie Legendre, Bernhard Riemann etc.) mit dem Problem befasst – wie in 

[Gol04] nachzulesen ist – und eine Abschätzung gefunden. Demnach gibt es für grosse 

ungefähr 

( ) 

Primzahlen, die kleiner als sind. Mit anderen Worten: Die für unseren 

Algorithmus massgebende Länge der Liste der Primzahlen hat für grosse ungefähr die 

Länge 

( ) . 

In fast allen Schleifen, die im Legendre Algorithmus durchlaufen werden müssen, ist die 

Länge der Primzahlliste – also 

( ) 

– die entscheidende Grösse. Die einzige Ausnahme bildet 

die Schleife für die Berechnung des Exponenten einer Primzahl in der Primzahlzerlegung von 

. Im Code sieht die Schleife so aus: 

int grenze = (int) Math.floor(Math.log(n) / Math.log(p)); 

for (int i = 1; i


Mit dieser Überlegung sieht man dass ( ) ( ( )) ist. 

Insgesamt haben wir also: 

( ) 

( ) 

( ) 

( 

( ) 

( ) ) ( ) 

Die Anzahl Schritte des Legendre-Algorithmus‘ wächst also ebenfalls linear mit der Grösse 

von an – wie der iterative Algorithmus. 

Wieso gibt es denn dann so grosse Unterschiede in der Berechnungszeit? 

- Der iterative Algorithmus berechnet in jedem Schritt Ausdrücke von der Form 

result = result * (n - i)/(i+1); 

Diese Zwischenresultate werden sehr schnell sehr gross und können Zahlen mit 

mehreren tausend Stellen umfassen. In jedem Schritt werden derart grosse Zahlen 

multipliziert. Das ist sehr aufwändig. 

- Der Legendre-Algorithmus dagegen rechnet stets mit Zahlen, die kleiner als sind. 

Erst ganz am Schluss, wenn das Schlussresultat aus den Primzahlpotenzen berechnet 

wird, entsteht eine grosse Zahl. 

Diese beiden Beobachtungen führen zum Schluss, dass die Anzahl der Operationen beider 

Algorithmen zwar linear von der Grösse von abhängen. Aber offenbar hängt die real 

benötigte Rechenzeit des iterativen Algorithmus‘ auch noch von der Grösse der 

Zwischenresultate ab. Und diese wachsen bei den Binomialkoeffizienten sehr rasant an. 

Fazit 

Wir haben am Beispiel der Berechnung von Binomialkoeffizienten gesehen, dass man mit 

einer raffinierten Idee einen Algorithmus entwickeln kann, der extrem grosse Zahlen in 

relativ kurzer Zeit berechnen kann. Voraussetzung dafür ist allerdings, dass man das 

mathematische Problem gut versteht. 

Ein weiteres Beispiel, wie mit einer pfiffigen mathematischen Idee ein langsamer 

Algorithmus extrem beschleunigt werden kann, wollen wir im nächsten Kapitel studieren. 



Fibonacci-Zahlen berechnen 

Die Folge der Fibonacci-Zahlen spielen in der Mathematik, in der Natur, in der Kunst und in 

der Architektur eine wichtige Rolle. Dies vor allem deshalb, weil sie eng mit dem goldenen 

Schnitt verwandt sind, der in der Antike – und in vielen Kreisen bis heute – als ein Mass für 

Ästhetik und Schönheit gilt. 

Die Fibonacci Zahlen gehen zurück auf den italienischen Mathematiker Leonardo Pisano, 

genannt Fibonacci (von Filio di Bonacci). Er lebte um 1200 herum und war Rechenmeister in 

Pisa. Sein grösstes Verdienst war, dass er die Mathematik aus dem arabischen Kulturraum 

wieder zurück nach Europa gebracht hat. In seinem Buch „Liber abaci“ erklärte er den 

Europäern, die bis dahin Zahlen nur mit römischen Ziffern geschrieben haben, dass man mit 

dem Gebrauch der Null ein Ziffernsystem erhält, das schriftliche Addition und Multiplikation 

erlaubt. 

In diesem Buch überlegte er sich auch, wie sich Kaninchen vermehren. Dies war die 

Geburtsstunde der Fibonacci-Folge, die so definiert ist: 

Ausgeschrieben: 

(Jedes Glied ist die Summe seiner beiden Vorgänger). 

In diesem Kapitel werden wir verschiedene Ansätze studieren, wie man algorithmisch ein 

berechnen kann, beispielsweise . 

Intuitiver Ansatz 

Die erste Idee für einen Algorithmus folgt der Definition der Fibonacci-Folge 

mit und . Diese besagt, dass man beispielsweise für die Glieder 

und benötigt. Für diese wiederum benötigt man und . Und so weiter. 

Diesen Ablauf möchten wir mit einer rekursiven Funktion, die sich selber aufruft, 

programmieren – ganz analog zum ersten Kapitel. 

Aufgabe 27 Schreiben Sie eine Klasse Fibonacci, die eine main-Methode enthält. 

Aufgabe 28 Fügen Sie der Klasse Fibonacci eine Methode int fibonacciRek(int n) 

bei, die das -te Glied der Fibonacci-Folge berechnet. 



Rechenaufwand 

Wenn Sie versuchen, mit dem Algorithmus aus Aufgabe 23 die Zahl zu berechnen, stellen 

Sie fest, dass er schon einige Zeit benötigt. Und für ist er bereits einige Sekunden am 

Rechnen. Weshalb? 

Um diese Frage zu beantworten, müssen wir erneut fragen, wie viele Schritte nötig sind, um 

zu berechnen. 

Dazu erstellen wir eine Tabelle, die aufzeigt, wie viele Schritte benötigt werden, um die 

ersten paar zu berechnen. 

Betrachten wir das Beispiel . 

Es wird folgendermassen gerechnet: 

n Schritte 

4 5 

5 9 

6 15 

7 25 

8 41 

9 67 

10 109 

11 177 

12 287 

13 465 

14 753 

15 1219 

Tab. 9 

Insgesamt wird die Funktion also 9 Mal aufgerufen. 



Aufgrund der rekursiven Struktur der Methode, setzt sich der Aufwand für die 

Berechnung von Zusammen aus dem Aufwand für die Berechnung von und dem 

Aufwand für die Berechnung von . Als Formel: 

⏟ 

Mit anderen Worten, der Aufwand für setzt sich zusammen aus den Aufwänden für und 

plus 1. Dies ist auch aus der Tabelle ersichtlich ⏟ ⏟ . 

Dies bedeutet, dass die Anzahl Rechenschritte Ziemlich genau mit der Zahl selbst 

übereinstimmt, die ebenfalls die Summe ihrer beiden Vorgänger ist. Betrachtet man die 

Zahlen aus Tab. 9 genauer und stellt sie grafisch dar, stellt man fest, dass die Entwicklung 

exponentiell ist (siehe Abbildung 1 unten). 

1400 

1200 

1000 

800 

600 

400 

200 

0 

Schritte 

1 2 3 4 5 6 7 8 9 10 11 12 

Abbildung 1 

Aufgabe 29 Berechnen Sie anhand der obigen Tabelle für wie sich der 

Wachstumsfaktor in der Funktion ( ) , die die Anzahl Schritte für ein 

bestimmtes angibt, entwickeln. Suchen Sie eine untere Grenze für . 

Erkenntnis 

Werden die Fibonacci-Zahlen mit einem rekursiven Algorithmus berechnet, so ist die Anzahl 

Schritte, die für Berechnung von nötig sind charakterisiert durch 

( ) ( ) 

Mit anderen Worten: Die Anzahl Schritte wächst mit steigendem 

ist damit sehr ineffizient. 

exponentiell schnell und 



Iterative Berechnung wie von Hand 

Wir versuchen deshalb, einen besseren Algorithmus für die Berechnung der Fibonacci-Zahlen 

zu finden. Bei dieser Suche überlegen wir uns, wie wir Menschen ohne technische Hilfsmittel 

die 15. Fibonacci-Zahl berechnen würden. Aufgrund unserer in diesem Bereich beschränkten 

Fähigkeiten, würden wir von Hand bestimmt keinen rekursiven Algorithmus anwenden, 

sondern versuchen, die Zahlen „straight forward“ aufzuschreiben. Wir beginnen mit den 

ersten zwei Zahlen, schreiben diese auf ein Blatt Papier und betrachten dann für die dritte 

Zahl ihre beiden Vorgänger und addieren diese. Für die 4. Zahl betrachten wir erneut die 

beiden Vorgänger und addieren diese. Mit diesem Verfahren gelangen wir früher oder 

später zu jeder beliebigen Fibonacci-Zahl. 

Wenn wir so vorgehen, eliminieren wir einen grossen Nachteil des obigen rekursiven 

Ansatzes. Dieser hat nämlich viele Zahlen mehrfach berechnet und damit den Aufwand 

aufgeblasen. Mit dem „von Hand“-Ansatz tun wir das nicht. Wir berechnen jede Zahl genau 

ein einziges Mal und benützen danach dieses Resultat für die Berechnung der weiteren 

Zahlen. 

Aufgabe 30 Entwickeln Sie einen Algorithmus int fibonacciIterativ(int n), der – 

unter Verwendung eines Arrays – die -te Fibonacci-Zahl berechnet und dabei jeweils 

ihre beiden Vorgänger ausnützt. Schreiben Sie ihre Funktion so, dass sie auch für 

ein richtiges Resultat liefert. 

Rechenaufwand 

Der Rechenaufwand dieses Algorithmus‘ findet hauptsächlich in der for-Schleife statt. Diese 

wird genau -2 mal durchlaufen, und in jedem Durchgang gibt es genau eine Addition und 

eine Zuweisung. Zudem benötigt der Algorithmus, bevor er zur Schleife kommt, zwei 

Schritte. Insgesamt ist also in diesem Fall ( ) ( ) ( ) 

. 

In der Schreibweise mit dem Landau-Symbol wird dieser Algorithmus charakterisiert durch 

( ) ( ) 

Mit anderen Worten: Der Rechenaufwand für die Berechnung der -ten Fibonacci-Zahl ist 

ungefähr proportional zu . 



Dies ist verglichen mit dem rekursiven Algorithmus ( ( 

Sprung! 

) ) ein massiver Effizienz- 

Raffinierte Iteration 

Auf den ersten Blick könnte man glauben, dass dieser Algorithmus der schnellst Mögliche ist. 

Denn es ist kaum vorstellbar, dass man eine -te Fibonacci-Zahl mit weniger als ungefähr 

Schritten berechnen kann. Doch wie wir schon bei den Binomialkoeffizienten gesehen 

haben, können mathematische Ideen uns helfen, äusserst pfiffige Algorithmen zu schreiben. 

Einen solchen Algorithmus wollen wir nun auch für die Berechnung der Fibonacci-Zahlen 

entwickeln. Sie werden erstaunt sein! 

Überlegung 

Wir betrachten ab jetzt nicht mehr nur eine einzige Fibonacci-Zahl, sondern jeweils zwei 

zusammen. Es gilt: 

Schreibt man dies in Matrix-Form, erhält man: 

( ) ( ) ( ) 

Was bringt uns das? Das Resultat fördert Erstaunliches zu Tage. Betrachtet man nämlich den 

Vektor ( 

) auf der rechten Seite, so entspricht dies gerade dem Vektor ( ). Diesem Vektor 

geben wir den Namen . Und entsprechend benennen wir den Vektor ( ) in um. 

Damit erhalten wir für den nächsten Vektor 

( ) ( ) ( ) ( ) 

⏟ 

( ) ( ) 

Dies entspricht einer impliziten Formel für das Folgenglied ! 

Denken wir den Gedanken weiter, so erhalten wir 

( ) ( ) ( ) 



Mit der Idee, die Fibonacci-Folge mit Matrizen zu berechnen, haben wir also erreicht, dass 

wir die -te Fibonacci-Zahl direkt mit einer impliziten Formel angeben können. Wir brauchen 

keine Vorgänger mehr zu berechnen! So finden wir zum Beispiel für 

( ) ( ) ( ) ( ) ( ) ( ) 

Damit ist . 

Allerdings hat die Sache noch einen Haken: Wir müssen ( ) berechnen. Und im 

Moment ist noch nicht klar, ob wir damit einen Geschwindigkeitsvorteil herausholen 

können. 

Matrix-Multiplikation 

Die Potenzierung einer Matrix mit dem Exponenten entspricht Multiplikationen mit 

sich selbst. Als Formel: 

( ) ( ) ( ) ( ) 

⏟ 

Für eine Multiplikation gilt: 

( ) ( ) ( ) ( ) 

Und allgemein: 

( ) ( ) ( ) 

Oder mit grafischen Hilfen dargestellt: 

( ) ( ) ( ) 

Um den Eintrag des Resultats zu berechnen, multipliziert man komponentenweise die 1. 

Zeile des ersten Faktors mit der 2. Spalte des zweiten Faktors. Diese Anleitung gilt allgemein 

für beliebige Matrizen mit Spalten und Zeilen. 

Um unser Problem weiter zu untersuchen, benötigen wir als erstes eine Klasse Matrix für 

quadratische Matrizen. 



Aufgabe 31 Berechnen Sie 

mit Hilfe der Matrix-Multiplikation. Das bedeutet 

berechnen Sie ( ) ( ) ( ) und lesen Sie dann aus dem Resultatvektor das 

entsprechende Resultat ab. 

Aufgabe 32 Schreiben Sie eine Klasse Matrix mit einem Konstruktor public 

Matrix(int m), wobei die Zahl die Dimension der quadratischen Matrix angibt. 

Schreiben Sie zudem eine Funktion public Matrix multiply(Matrix b), die prüft 

ob die Matrix B die gleiche Dimension hat wie die Matrix A und danach die beiden 

Matrizen multipliziert. 

Schreiben Sie eine Funktion public int getEntry(int row, int col), die den 

Eintrag der Matrix an der entsprechenden Stelle liefert. 

Schreiben Sie eine Funktion public void setEntry(int row, int col, int 

val), die den entsprechenden Eintrag in der Matrix setzt. 

Schnelles Potenzieren 

Nun hätten wir im Prinzip alle Werkzeuge, um grosse Fibonacci-Zahlen algorithmisch zu 

berechnen. Der Algorithmus in Pseudocode, würde so aussehen: 

fibonacci(n){ 

Erzeuge Matrix ( ) -> M 

Berechne -> M 

Gib den zweiten Eintrag von 

} 

( ) aus. 

Das Problem dieses Algorithmus‘ ist jedoch, dass die Berechnung von aus genau 

Multiplikationen mit sich selber besteht. Und jede Multiplikation einer Matrix mit sich 

selbst benötigt 8 Schritte – insgesamt also ( ) Schritte. Würden wir 

diesen Weg gehen, hätten wir gegenüber dem iterativen Algorithmus nichts gewonnen. Wir 

brauchen noch eine neue Idee! 

Schnelles Potenzieren mit reellen Zahlen 

Wir versuchen, eine Idee zu finden, die uns beim Potenzieren hilft. Als erstes betrachten wir 

das Potenzieren von reellen Zahlen. Das reduziert den Schreibaufwand. Danach werden wir 

die Idee auf die Matrizen übertragen. Das Ziel dieser Idee ist, die Anzahl Multiplikationen 

beim Berechnen von zu reduzieren. 



Betrachten wir beispielsweise , so berechnet man dies normalerweise als . Dies 

entspricht drei Multiplikationen. Schreibt man allerdings 

plötzlich nur noch 2 Multiplikationen durchführen: 

leicht um zu ( ) , so muss man 

- Im ersten Schritt berechnet man und merkt sich das Resultat und sagt ihm zum 

Beispiel . 

- Im zweiten Schritt berechnet man und hat das Resultat bereits gefunden. 

Die Einsparung an Multiplikationen in diesem Beispiel rührt daher, dass der Exponent 4 

gerade eine Potenz von 2 ist. Damit lässt er sich als Kette von Quadraten schreiben. 

Doch wie sieht es aus, wenn man Beispielsweise berechnen will? Würde man diese 

Potenz als ⏟ berechnen, müsste man 9 Multiplikationen durchführen. Viel schneller 

ist es jedoch, wenn man es umformt zu (( ) ) . 

Damit müssen folgende Multiplikationen ausgeführt werden: 

Mit diesem Trick sind nur 4 Multiplikationen nötig! Ein ordentlicher Fortschritt gegenüber 9 

Multiplikationen. 



mit 5 Multiplikationen. 

mit möglichst wenig Multiplikationen. 

Aufgabe 35 Berechnen Sie auf zwei verschiedene Arten mit jeweils 3 


Aufgabe 36 Wie viele Multiplikationen sind mindestens nötig, um 

Aufgabe 37 Wie viele Multiplikationen sind mindestens nötig, um 

zu berechnen? 

zu berechnen? 

System für die schnelle Exponentiation 

Um ein System für die schnelle Exponentiation zu finden, betrachten wir noch einmal 

( ) und schreiben die nötigen Multiplikationen als Kette auf. Man beginnt mit , 



multipliziert mit sich selbst und multipliziert dieses Resultat noch einmal mit sich selbst. Man 

startet also mit und quadriert das Resultat zwei Mal hintereinander. 

Als Kette dargestellt sieht das so aus: 

Dabei steht 

für Quadrieren. 

Betrachten wir das Beispiel . Dies lässt sich schreiben als ( ) und benötigt drei 

Multiplikationen. Oder als Kette: 

Im Unterschied zur Berechnung von gibt es in dieser Kette nicht nur , sondern am 

Schluss muss man einmal noch mit 

Multiplizieren. 

Die Frage ist nun, ob sich diese Idee so verallgemeinern lässt, so dass man – ohne lange 

ausprobieren zu müssen – eine Regel angeben kann, wie sich beispielsweise 

in eine Kette von Quadrieren und Multiplizieren verwandeln lässt. 

oder 

Um dieses Muster zu finden (siehe 0), schreiben wir die obigen Ketten noch leicht um. Jede 

Kette beginnt mit einer 1. Diese wird dann sukzessive quadriert und mit 

Schreibweise hilft beim Finden des Musters: 

multipliziert. Diese 

(Kurz: ) 

: (Kurz: ) 

: (Kurz: ) 

Beispiele tabellarisch: 

Potenz 

Anz. Multiplikationen 

( ) Dies entspricht3 Multiplikationen (wenn man erst bei zu 

zählen beginnt): 

1. mit sich selber -> 

2. mit sich selber -> 

3. mit -> Schlussresultat 

Oder als Kette (mit 1 beginnend): 

( ) 

3 Multiplikationen. 

Als Kette: 

( ) 4 Multiplikationen. 



Als Kette: 

(( ) ) 


(( ) ) 


Aufgabe 38 Führen Sie die obige Tabelle weiter, suchen Sie eine Regelmässigkeit und 

versuchen Sie, diese Regelmässigkeit in Worte zu fassen. 

Führt man die obige Tabelle nach dem gleichen Muster wie am Anfang weiter, stellt man 

fest, dass die Folgen der und gerade der Binärdarstellung des Exponenten 

entspricht, wenn man durch und durch erstetzt. 

Beispiel: 

(Der tiefgestellte Index 2 deutet die Binärdarstellung an.) Damit heisst 

die Kette: oder oder (( ) ) . 

Betrachtet man die Ketten – mit 1 beginnend – etwas genauer, stellt man fest, dass die erste 

Quadrierung und die erste Multiplikation mit benötigt werden, um aus einer 1 ein zu 

erhalten. Diesen Schritt kann man auch weglassen und direkt mit beginnen. Dies entspricht 

dem Weglassen der ersten 1 in der Binärdarstellung 

Die Berechnung von besteht nun also darin, die Binärdarstellung von 1413 zu finden 

und danach die entsprechende Kette von und aufzuschreiben: 

1. Binärdarstellung von 

2. Erste 1 weglassen: 

3. Kette aufschreiben: (((((((( ) ) ) ) ) ) ) ) 

lässt sich also mit 12 Multiplikationen berechnen! 

Aufgabe 39 Erstellen Sie die Kette für die Berechnung von 

Exponentiation. 

Aufgabe 40 Erstellen Sie die Kette für die Berechnung von 

Exponentiation. 

mittels schneller 

mittels schneller 

Damit haben wir nun alle Ideen beisammen, um einen Algorithmus zu entwickeln, mit dem 

sich grosse Potenzen schnell berechnen lassen. 



Der Algorithmus besteht aus folgenden Schritten: 

binär[]


Die Anzahl Multiplikationen hängt jedoch nicht alleine von dieser Länge ab, sondern auch 

noch von der Anzahl der Einsen in der Binärdarstellung. Dabei gilt, dass für jede 1 in der 

Binärdarstellung zwei Multiplikationen nötig sind (einmal Quadrieren, einmal mit 

multiplizieren). Für jede 0 in der Binärdarstellung schlägt eine Multiplikation zu Buche, 

nämlich ein einfaches Quadrieren. 

Damit lässt sich nun die Anzahl 

( ) der Multiplikationen berechnen: 

( ) ⏟ ( ) 

⏟ ( ) 

Nachdem es in der Binärdarstellung von höchstens ( ) viele geben kann, erhält 

man insgesamt 

( ) ( ) ( ( )) 

Die Frage ist nun noch, ob dieses Verfahren optimal ist? Die Antwort ist klar: Nein. Am 

besten sieht man das am Beispiel . Unser Verfahren liefert: 

. Dies entspricht 6 Multiplikationen. Das gleiche Resultat 

könnte man aber auch erzielen, indem man mit 2 Multiplikationen zuerst berechnet 

und danach mit dem obigen Verfahren in drei Multiplikationen berechnet. Damit 

benötigte man also insgesamt nur 5 Multiplikationen (siehe [Don98] S.462). Doch der 

Unterschied ist auch für grössere sehr gering. Und immerhin benötigt unser Verfahren 

weniger als Schritte, um Potenzen mit einem grossen Exponenten zu berechnen. 

Das soeben entwickelte Verfahren, um Potenzen mit grossen Exponenten zu berechnen, 

heisst in der Literatur binäre Exponentiation oder auch Square&Multiply (Square, engl. für 

Quadrieren). Leider können wir hier nicht für uns beanspruchen, etwas Neues gefunden zu 

haben. Denn dieser Algorithmus wurde schon ca. 200 v. Chr. in Indien entdeckt und wurde 

erstmals erwähnt in einem Werk namens „Chandah-sûtra“. 

Nun mit Matrizen 

Das Verfahren der binären Exponentiation funktioniert auch mit Matrizen, denn bei allen 

obigen Überlegungen haben wir uns nur mit dem Exponenten befasst. Nirgends gibt es eine 

Einschränkung in Bezug auf die Basis – also darf die Basis auch eine Matrix sein. Damit sind 

wir nun in der Lage, einen Algorithmus zu entwickeln, um die -te Fibonacci-Zahl mit 

( ) ( ) direkt zu berechnen. Für die Berechnung von ( ) werden wir 



selbstverständlich die binäre Exponentiation benützen, um diese Potenzen schnell 

durchzuführen. 

Dazu benötigen wir als erstes die folgende Aufgabe. 

Aufgabe 43 Erweitern Sie die Klasse Matrix um die Methode Matrix fastExp(Matrix 

a, int n), die mit Hilfe der schnellen Exponentiation berechnet mit . 

Wenn Sie die Aufgabe 43 richtig gelöst haben, verfügen Sie nun über eine komplette Klasse, 

um die -te Fibonacci-Zahl direkt zu berechnen. Ob der Algorithmus auch wirklich schnell ist, 

werden wir im nächsten Abschnitt prüfen. Ob er auch korrekt ist, werden Sie mit der 

folgenden Aufgabe feststellen. 

Aufgabe 44 Ergänzen Sie die Klasse Fibonacci um eine Methode int 

fibonacciFast(int n), die als Input einen natürliche Zahl erhält und als Output 

die -te Fibonacci Zahl zurückgibt. 

Prüfen Sie ihre neue Methode, indem Sie aus der main-Methode heraus einige 

Fibonacci-Zahlen berechnen. 

Wenn Sie ihre neue Methode ausgiebig getestet haben und dabei auch versucht haben, die 

entsprechenden Fibonacci-Zahlen zu grossen zu berechnen, werden Sie festgestellt haben, 

dass die Resultate nicht korrekt, resp. negativ sind. Dies hat damit zu tun, dass der Bereich 

von Zahlen, die mit einem Integer int dargestellt werden können, begrenzt ist, und 

Fibonacci-Zahlen sehr schnell sehr gross werden können. Dieses Problem lässt sich beheben, 

indem im gesamten Code alle int-Variablen, die grosse Werte annehmen können, durch 

Objekte vom Typ BigInteger ersetzt werden. Diese Objekte können (fast) beliebig grosse 

Zahlen verarbeiten und darstellen. Im Anhang findet sich die abgeänderte Klasse 

Fibonacci, die in der Lage ist, sehr grosse Zahlen zu berechnen. 

Geschwindigkeitssprung 

Schliesslich bleibt noch zu prüfen, was wir mit dieser Idee an Effizienz gewonnen haben. 

Schon der iterative Ansatz zur Berechnung einer Fibonacci-Zahl brachte einen drastischen 

Gewinn gegenüber der Rekursiven Berechnung. Mit der Idee, die Berechnung mit Matrizen 

anzustellen, können wir noch einmal eine deutliche Beschleunigung feststellen. 

Im letzten Absatz haben wir festgehalten, dass die Anzahl schnelle Exponentiation 

( ) ( ) Multiplikationen durchführt (im schlimmsten Fall). Wir müssen 



also noch überlegen, mit wie vielen Berechnungsschritten die Multiplikation zweier - 

Matrizen zu Buche schlägt. 

Wir zählen die Operationen, die nötig sind, um zwei -Matrizen zu multiplizieren. Dabei 

betrachten wir zuerst, wie viele Operationen durchgeführt werden müssen, um einen 

einzigen Eintrag in der Resultat-Matrix zu berechnen: 

- Jeder Eintrag einer Zeile wird mit einem Eintrag einer Spalte multipliziert 


- Die Resultate dieser Multiplikationen werden miteinander addiert 

Additionen. 

Zusammen haben wir also für die Berechnung eines einzigen Eintrages im Resultat 

Operationen. 

Insgesamt müssen 

Einträge berechnet werden. Zusammen erhalten wir also 

( ) 

Operationen. 

In unserem Fall der 

-Matrix ergibt dies 12 Operationen für eine Multiplikation. Diese 

Anzahl bleibt für jede Multiplikation gleich, da die Grösse der Matrix nicht ändert. Was sich 

für grosse 

werden. 

ändert, sind allein die Einträge in der Matrix, die relativ schnell relativ gross 

Verrechnen wir nun die schnelle Exponentiation und die Matrix-Multiplikation, erhalten wir 

die Anzahl Schritte 

berechnen. 

( ), um mit Hilfe der Matrix das -te Glied der Fibonacci-Folge zu 

( ) ⏟ ( ) 

⏟ ( ) ( ( )) 

Die Idee mit der Matrix hat sich also ausbezahlt. Das ist von den drei hier vorgestellten 

Algorithmen mit Abstand der schnellste, um die Fibonacci-Zahl 

zu berechnen. 


10 

50 

90 

130 

170 

210 

250 

290 

330 

370 

410 

450 

490 

Shritte 


In der nebenstehenden Grafik 

ist der Effizienzsprung 

offensichtlich. Die Schrittzahl 

des rekursiven Algorithmus‘ ist 

nicht dargestellt. Denn dieser 

wächst exponentiell und 

übertrifft die anderen beiden 

bei weitem. In der Grafik sieht 

man, dass der iterative 

1200 

1000 

800 

600 

400 

200 

0 

n 

Algorithmus für kleine bis ca. 75 schneller ist. Für grössere wächst jedoch die Anzahl 

Schritte des Matrix-Algorithmus‘ deutlich weniger schnell. 

Iterativ 

Matrix 

Berechnung mit der Formel von Moivre-Binet 

Wie sie vielleicht aus dem Mathematik-Unterricht wissen, lassen sich die Fibonacci-Zahlen 

auch direkt berechnen. Die Formel heisst: 

√ (( √ √ ) ( ) ) 

Sie wurde von den französischen Mathematikern Abraham de Moivre und Jacques Philippe 

Marie Binet unabhängig voneinander in den Jahren 1730 und 1843 entdeckt. Die Frage ist 

nun, weshalb wir nicht einen Algorithmus schreiben, der das -te Fibonacci-Glied direkt mit 

der Formel berechnet und so viel Aufwand sparen kann. 

Das Problem dabei ist, dass diese Idee zu keinem Geschwindigkeitsgewinn führen würde. 

Denn der Algorithmus müsste ja ebenfalls zwei Mal eine Potenz mit im Exponenten 

ausrechnen. Dies kann aber nicht schneller geschehen, als mit dem eben entwickelten 

Algorithmus. Zudem müsste der Algorithmus mit der reellen Zahl √ rechnen, was für 

Computer ein grosses Problem darstellt, da mit reellen Zahlen nicht exakt gerechnet werden 

kann. 

Der von uns entwickelte Algorithmus ist damit effektiv der schnellst mögliche Weg, um mit 

einem Computer die -te Fibonacci-Zahl zu berechnen. 



Fazit 

Rekursion ist in vielen Bereichen der Algorithmik ein wichtiges Instrument, um Probleme zu 

lösen. Allerdings hat der rekursive Ansatz oft den Nachteil, dass er viele – oft unnötige – 

Berechnungsschritte durchführen muss. In dieser Unterrichtseinheit haben wir gesehen, 

dass man mit Ideen aus der Mathematik Berechnungsprobleme, die auf den ersten Blick 

nach einer Rekursion aussehen, deutlich effizienter lösen kann. 

Vor allem das Beispiel der Fibonacci-Zahlen hat gezeigt, dass es sehr hilfreich sein kann, in 

die mathematische Trickkiste zu greifen und damit einen pfiffigen Algorithmus zu 

entwickeln. Voraussetzung dafür ist natürlich, dass man sich traut, das Problem tiefgreifend 

zu analysieren und die mathematischen Ideen umzusetzen. 

Dieses Vorgehen ist typisch für die Informatik: Der intuitive Ansatz funktioniert zwar. Mit viel 

Ideenreichtum und Kreativität gelingt es einem jedoch, die Berechnungszeit radikal zu 

verkürzen. Ein äusserst aktuelles Problem, das noch darauf wartet, effizient gelöst zu 

werden, ist die Zerlegung einer sehr grossen Zahl in ihre zwei Primfaktoren. Bisher benötigen 

alle Versuche, dieses Problem zu lösen, sehr viel Rechenzeit. Zum Glück! Denn ein grosser 

Teil der Datensicherheit im Internet oder beim Online-Banking beruht darauf, dass bisher 

niemand einen schnellen Algorithmus gefunden hat. Aber wer weiss: Vielleicht findet sich 

irgendwann jemand, der mit einer sehr pfiffigen Idee ein schnelles Verfahren findet. Im 

Prinzip ist es – mindestens nach heutigem Wissensstand – möglich! 



Literaturverzeichnis 

[Möh08] MÖHRING, ROLF, OELLRICH, M.: Das Sieb des Eratosthenes: Wie schnell kann man 

eine Primzahl berechnen? In Vöcking, Berthold, Alt, H. et al. (eds.) : Taschenbuch 

der Algorithmen. Springer-Verlag, Berlin Heidelberg (2008). P. 127-138 

[Gol04] GOLDFELD, DORIAN: The elementary proof of the prime number theorem: an 

historical perspective. In Chudnovsky, David, et al. (eds.) : Number theory: New 

York seminar 2003. Springer, New York (2004). P. 179-192 

[Woh10] WOHLGEMUTH, MARTIN: Berechnung grosser Binomialkoeffizienten. In : 

Mathematisch für fortgeschrittene Anfänger. Spektrum Akademischer Verlag, 

Heidelberg (2010) 

[Hro07] HROMKOVIC, JURAJ: Theoretische Informatik. B.G. Teubner Verlag, Wiesbaden 

(2007) 


Anhänge 

I. Lösungen zu den Aufgaben 

II. Gesamte Klasse für die Binomialkoeffizienten-Berechnung 

III. Klassen für die Fibonacci-Zahlen 

Anhänge I

I. Lösungen zu den Aufgaben 

Aufgabe 1 

public class BinKoeff { 

public static void main(String[] args) { 

int n=5; 

int k=1; 

System.out.println(n+" tief "+ k +" = "+ binKoeffRek(n, k)); 

} 

} 

public static int binKoeffRek(int n, int k) { 

if (k == 0 || k == n) { 

return 1; 

} else { 

return binKoeffRek(n - 1, k - 1) + binKoeffRek(n - 1, k); 

} 

} 

Aufgabe 2 

Diese Methode liefert die Outputs: Beispielen ( ) ( ) ( ) ( ) ( ) ( ) ( ) 

- 5 tief 1 = 5 

- 5 tief 0 = 1 

- 6 tief 3 = 20 

- 0 tief 0 = 1 

- 6 tief 6 = 1 

- 11 tief 7 = 330 

- 45 tief 6 = 9366819 

Letztere Zahl besagt übrigens, wie viele mögliche verschiedene Lottoscheine es in der 

Schweiz geben kann. 

Wie man mit dem Pascalschen Dreieck nachprüfen kann, liefert der Algorithmus 

immer die richtige Zahl. 

Anhänge II

Aufgabe 3 

/** 

* Diese Methode erzeugt einen zweidimensionalen Array mit 

unterschiedlichen 

* Zeilen-Längen und berechnet die Werte des Pascalschen Dreiecks. Dabei 

* gilt: pascal[n][k] entsrpicht dem Wert von "n tief k". 

* 

* @param n 

* @param k 

* @return 

*/ 

public static int binKoeffPascal(int n, int k) { 

int[][] pascal = new int[n + 1][]; 

for (int i = 0; i

( ) 

( ) 

6 33 36 0.92 

7 42 49 0.86 

8 52 64 0.81 

9 63 81 0.78 

10 75 100 0.75 

20 250 400 0.63 

30 525 900 0.58 

50 1375 2500 0.55 

75 3000 5625 0.53 

100 5250 10000 0.50 

1000 502500 1000000 0.50 

10000 50025000 100000000 0.50 

100000 5000250000 1E+10 0.50 

Tab. 11 

Offenbar scheint der Wert 

( ) 

gegen den Wert zu konvergieren. 

Dies überprüfen wir nun analytisch: 

( ) 

⏟ 

Die Beobachtung wird also durch die analytische Überlegung gestützt. Je grösser 

wird, desto eher nähert sich ( ) dem Wert an. 

Aufgabe 6 

Man berechnet 

Aufgabe 7 Wenn ( ) ( ) liegen soll, muss 

( ) 

gelten. 

( ) 

( ) ( ) 

Aufgabe 8 Der grösste Exponent ist 3 in deshalb berechnen wir: 

Die Funktion liegt also in ( ). 

Aufgabe 9 

Es gilt also: ( ). Die Konstante . 

Anhänge IV

Aufgabe 10 ( ) 

Deshalb: ( ) 

Aufgabe 11 

Deshalb: ( ), für alle . . 

Aufgabe 12 

Wir haben uns überlegt, dass sich die Funktion für jede Zeile des Pascalschen 

Dreiecks zwei Mal selbst aufruft. Damit kommt man auf ungefähr Aufrufe der 

Funktion und somit auch auf eine Grössenordnung von . 

Damit ist ( ) ( ). 

Aufgabe 13 

public static int binKoeffIterativ(int n, int k) { 

int result = 1; 

for (int i = 0; i < k; i++) { 

result = result * (n - i)/(i+1); 

} 

return result; 

} 

Aufgabe 14 Wenn 

Aufgabe 15 Wenn 

Aufgabe 16 Jeder 2. Faktor ist durch 2 teilbar. Also bei sind es 4. 

Aufgabe 17 Jeder 4. Faktor ist durch 4 teilbar. Bei sind es 2. 

Aufgabe 18 ⌊ ⌋ ( auf die nächst kleinere ganze Zahl abgerundet) 

Aufgabe 19 ⌊ 

⌋ 

Aufgabe 20 

3 erhält als Exponent ⌊ ⌋ ⌊ ⌋ 

5 erhält als Exponent ⌊ ⌋ 

Anhänge V



Zusammen: 

Aufgabe 21 ( ) ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ 4 Summanden 

Aufgabe 22 

( ) ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ ⌊ ⌋ 

⌊ ⌋ ⌊ ⌋ 10 Summanden. 

Aufgabe 23 Nach den beiden obigen Aufgaben sieht man, dass die Anzahl Summanden 

gerade dem Wert ( ) entspricht. Also hat ( ) genau ( ) 

Summanden. 

Aufgabe 24 Allgemein gilt ( ) hat ( ) Summanden. 

Aufgabe 25 

public static int calculatePower(int p, int n) { 

int pow = 0; 

// log(n)zur Basis p lässt sich berechnen mit ln(n)/ln(p) 

for (int i = 1; i

Aufgabe 27 siehe Aufgabe 27 

Aufgabe 28 

public class Fibonacci { 


System.out.println(fibonacciRek(30) + " "); 

} 

} 

public static int fibonacciRek(int n) { 

if (n == 1 || n == 2) { 

return 1; 

} 

return fibonacciRek(n - 1) + fibonacciRek(n - 2); 

} 

Aufgabe 29 

Aus der Tabelle 

n Schritte Wachst.faktor 

4 5 

5 9 1.8 

6 15 1.66666667 

7 25 1.66666667 

8 41 1.64 

9 67 1.63414634 

10 109 1.62686567 

11 177 1.62385321 

12 287 1.62146893 

13 465 1.62020906 

14 753 1.61935484 

15 1219 1.6188579 

wird ersichtlich, dass sich die Faktoren, um die die Schritte zunehmen, laufend 

verkleinern. Allerdings wird die Abnahme mit steigendem kleiner. Als Grenzwert 

zeichnet sich eine Zahl ab. 

Anhänge VII

Aufgabe 30 

public static int fibonacciIterativ(int n) { 

//Wenn n 0 && col > 0 && row

} 

*/ 

public int getEntry(int row, int col) throws ArrayIndexOutOfBoundsException { 

if (row > 0 && col > 0 && row

(( ) ) 

(4 Multiplikationen) 

(( ) ) 


(( ) ) 


etc. 

(( ) ) 


Regelmässigkeit: Die Kette mit den Zeichen „ 

“ und „ “ ist identisch mit der 

Binärdarstellung des Exponenten, wenn man durch und 0 durch ersetzt. 

Aufgabe 39 (((( ) ) ) ) 

Aufgabe 40 (((((((( ) ) ) ) ) ) ) ) 

Aufgabe 41 

/** 

* Erzeugt einen Array, der die Binärdarstellung von n enthält. Bedingung: n>=0. 

*/ 

public static int[] binary(int n) { 

int[] result = { 0 }; 

if (n > 0) { 

//Länge des Arrays ist floor(log_2(n))+1 

result = new int[(int) (Math.log(n) / Math.log(2)) + 1]; 

int rest = 1; 

int index = 1; 

while (n != 0) { 

rest = n % 2; 

result[result.length - index++] = rest; 

n = n / 2; 

} 

} 


} 

Aufgabe 42 

/** 

* Berechnet mit Hilfe der schnellen Exponentiation die Potenz b^e. 

* @param b 

* @param e 

* @return 

*/ 

public static long fastExp(int b, int e) { 

int[] binaryOfExp = binary(e); 

//Startwert für die schnelle Exponentiation 

long res = b; 

//Das erste Bit der Binärdarstellung wird ignoriert. 

for(int i=1;i

** 

* Berechnet mit Hilfe der schnellen Exponentiation die Potenz b^e. 

* @param b 

* @param e 

* @return 

*/ 

public static BigInteger fastExp(int b, int e) { 

int[] binaryOfExp = binary(e); 

//Startwert für die schnelle Exponentiation 

BigInteger res = BigInteger.valueOf(b); 

//Das erste Bit der Binärdarstellung wird ignoriert. 

for(int i=1;i

** 

* Berechnet das n-te Fibonacci-Glied mit schneller Matrix-Exponentiation 

* 

* @param n 

* @return 

*/ 

public static int fibonacciFast(int n) { 

Matrix fib = getFibonacciMatrix(); 

fib = fib.fastExp(n - 1); 

return fib.getEntry(2, 1) + fib.getEntry(2, 2); 

} 

/** 

* Berechnet die Fibonacci-Matrix |1 1| |1 0| 

* 

* @return 

*/ 

public static Matrix getFibonacciMatrix() { 

Matrix res = new Matrix(2); 

res.setEntry(1, 1, 1); 




return res; 

} 

/** 

* Erzeugt einen Array, der die Binärdarstellung von n enthält. Bedingung: 

* n>=0. 

*/ 



if (n > 0) { 

// Länge des Arrays ist floor(log_2(n))+1 


int rest = 1; 


while (n != 0) { 

rest = n % 2; 


n = n / 2; 

} 

} 


} 

Anhänge XII

II. 

Gesamte Klasse für die Binomialkoeffizienten-Berechnung 

BinKoeff.java 

package binomialkoeff; 

import java.math.BigInteger; 

public class BinKoeffOpt { 


int n = 10000; 

int k = 5000; 

long start = System.nanoTime(); // Zeit beim Start 

binKoeffIterativ(n, k); 

System.out.println("Iterativ: " + (System.nanoTime() - start) / 1.E9 

+ " sec."); 

int[] primes = getPrimes(n); 

start = System.nanoTime(); 

binKoeffLegendre(n, k, primes); 

System.out.println("Legendre: " + (System.nanoTime() - start) / 1.E9 

+ " sec."); 

} 

public static int binKoeffRek(int n, int k) { 

if (k == 0 || k == n) { 

return 1; 

} else { 

return binKoeffRek(n - 1, k - 1) + binKoeffRek(n - 1, k); 

} 

} 

/** 

* Iterative Methode, um den Binomialkoeffizient "n tief k" zu berechnen. 

* Dabei wird das Resultat in BigInteger gespeichert. Dieses 

* Objekt kann fast beliebig grosse ganze Zahlen speichern. 

* 

* @param n 

* 

* @param k 

* 

* @return BigInteger 

*/ 

public static BigInteger binKoeffIterativ(int n, int k) { 

BigInteger result = new BigInteger("1"); 

for (int i = 0; i < k; i++) { 

result = result.multiply(new BigInteger(Integer.toString(n - i))) 

.divide(new BigInteger(Integer.toString(i + 1))); 

} 


} 

/** 

* Methode, um mit dem Satz von Legendre "n tief k" zu berechnen. Dabei wird 

* das Resultat in BigInteger gespeichert. Dieses Objekt kann 

* fast beliebig grosse ganze Zahlen speichern. 

* 

* @param n 

* 

* @param k 

* 

* @param primes 

* Integer Array, der die Liste aller 

* Primzahlen hält, die kleiner als n sind. 


*/ 

public static BigInteger binKoeffLegendre(int n, int k, int[] primes) { 

BigInteger res = new BigInteger("1"); 

int[] exponenten = new int[primes.length]; 

primeFakt(primes, exponenten, 1, n); 

primeFakt(primes, exponenten, -1, k); 

primeFakt(primes, exponenten, -1, n - k); 

for (int i = 0; i < exponenten.length; i++) { 

if (exponenten[i] != 0) { 

res = res.multiply(new BigInteger(Long.toString((long) (Math 

.pow(primes[i], exponenten[i]))))); 

} 

} 

return res; 

} 

/** 

* Berechnet die Primfaktorzerlegung von k!. Die Exponenten der einzelnen 

* Primzahlen werden zu den bereits vorher berechneten Exponenten in 

* exponenten addiert (z >0) oder subtrahiert (z

* 

* @param primes 

* Array, der die Primzahlen < n enthält. 

* @param exponenten 

* Array, der die Exponenten der 

* Primzahlzerlegung hält. Dieser Array wird durch diese Methode 

* verändert. 

* @param z 

* Ist z>0, werden die berechneten Exponenten 

* zu den bestehenden Exponenten addiert. Ist z

} 

} 

pow = pow + quot; 

quot = (int) quot / p; 

} 

return pow; 

Anhänge XV

III. 

Klassen für die Fibonacci-Zahlen 

Fibonacci.java 

package fibonacci; 


public class Fibonacci { 


int n = 43; 

} 

System.out.println("Rekursiv: " + fibonacciRek(n)); 

start=System.currentTimeMillis(); 

System.out.println("Iterativ: " + fibonacciIterativ(n)); 

start=System.currentTimeMillis(); 

System.out.println("Schnelle Exp. : " + fibonacciFast(n)); 

/** 

* Berechnet das n-te Fibonacci-Glied mittels Rekursion 

* 

* @param n 

* @return 

*/ 

public static int fibonacciRek(int n) { 

if (n == 1 || n == 2) { 

return 1; 

} 

return fibonacciRek(n - 1) + fibonacciRek(n - 2); 

} 

/** 

* Berechnet das n-te Fibonacci-Glied iterativ 

* 

* @param n 

* @return 

*/ 

public static int fibonacciIterativ(int n) { 

// Wenn n

** 

* Berechnet das n-te Fibonacci-Glied mittels schneller 

* Matrix-Exponentiation 

* 

* @param n 


*/ 

public static BigInteger fibonacciFastBigInt(int n) { 

MatrixBigInt fib = getFibonacciMatrixBigInt(); 


return fib.getEntry(2, 1).add(fib.getEntry(2, 2)); 

} 

/** 

* Berechnet die Fibonacci-Matrix |1 1| |1 0| Die Werte in der Matrix sind 

* BigInteger 

* 

* @return MatrixBigInteger 

*/ 

public static MatrixBigInt getFibonacciMatrixBigInt() { 

MatrixBigInt res = new MatrixBigInt(2); 

res.setEntry(1, 1, BigInteger.valueOf(1)); 




return res; 

} 

/** 

* Berechnet das n-te Fibonacci-Glied mit schneller Matrix-Exponentiation 

* 

* @param n 

* @return 

*/ 

public static int fibonacciFast(int n) { 

Matrix fib = getFibonacciMatrix(); 


return fib.getEntry(2, 1) + fib.getEntry(2, 2); 

} 

/** 

* Berechnet die Fibonacci-Matrix |1 1| |1 0| 

* 

* @return 

*/ 

public static Matrix getFibonacciMatrix() { 

Matrix res = new Matrix(2); 





return res; 

} 

} 

/** 

* Erzeugt einen Array, der die Binärdarstellung von n enthält. Bedingung: 

* n>=0. 

*/ 



if (n > 0) { 

// Länge des Arrays ist floor(log_2(n))+1 


int rest = 1; 


while (n != 0) { 

rest = n % 2; 


n = n / 2; 

} 

} 


} 

Anhänge XVII

Matrix.java 



public class Matrix { 

private int[][] mat; 

private int dim; 

/** 

* Konstruktor für die quadratische Matrix mit Dimension m. 

* 

* @param m 

*/ 

public Matrix(int m) { 

dim = m; 

mat = new int[m][m]; 

} 

/** 

* Setzt das Matrix-Element mat_(row,col) auf den Wert val. 

* 

* @param row 

* @param col 

* @param val 

*/ 

public void setEntry(int row, int col, int val) { 

if (row > 0 && col > 0 && row 0 && row

* @param n 

* @return 

*/ 

public Matrix fastExp(int n) { 

Matrix result = new Matrix(this.dim); 

// Matrix kopieren 

for (int row = 1; row

MatrixBigInt.java 



public class MatrixBigInt { 

private BigInteger[][] mat; 

private int dim; 

/** 

* Konstruktor für die quadratische Matrix mit Dimension m. 

* 

* @param m 

*/ 

public MatrixBigInt(int m) { 

dim = m; 

mat = new BigInteger[m][m]; 

} 

/** 

* Setzt das Matrix-Element mat_(row,col) auf den Wert val. 

* 

* @param row 

* @param col 

* @param val 

*/ 

public void setEntry(int row, int col, BigInteger val) { 

if (row > 0 && col > 0 && row 0 && row

} 

} 

int[] binaryOfExp = Fibonacci.binary(n); 

// Das erste Bit der Binärdarstellung wird ignoriert. 

for (int i = 1; i < binaryOfExp.length; i++) { 

// Quadrieren 

result = result.multiply(result); 

if (binaryOfExp[i] == 1) { 

// Mit sich selber multiplizieren 

result = result.multiply(this); 

} 

} 


} 

/** 

* Gibt die Matrix in lesbarer Form an der Konsole aus. 

*/ 

public void printMatrix() { 

for (int row = 1; row

Pfiffige Algorithmen - ABZ

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?