Mathematische Rekursion
|
|
|
- Swen Vogel
- vor 6 Jahren
- Abrufe
Transkript
1 Rekursion
2 Mathematische Rekursion o Viele mathematische Funktionen sind sehr natürlich rekursiv definierbar, d.h. o die Funktion erscheint in ihrer eigenen Definition.
3 Mathematische Rekursion o Viele mathematische Funktionen sind sehr natürlich rekursiv definierbar, d.h. o die Funktion erscheint in ihrer eigenen Definition. n! = 1, falls n 1 n (n-1)!, falls n > 1
4 Rekursion in C++ o modelliert oft direkt die mathematische Rekursionsformel
5 Rekursion in C++ o modelliert oft direkt die mathematische Rekursionsformel. // POST: return value is n! unsigned int fac (unsigned int n) { if (n <= 1) return 1; return n * fac(n-1); // n > 1
6 Unendliche Rekursion o ist so leicht zu erzeugen wie eine unendliche Schleife, o sollte aber genauso vermieden werden.
7 Unendliche Rekursion o ist so leicht zu erzeugen wie eine unendliche Schleife, o sollte aber genauso vermieden werden. void f() { f(); // calls f(), calls f(), calls f(),...
8 Terminierung von rekursiven Funktionsaufrufen Wie bei Schleifen brauchen wir o Fortschritt Richtung Terminierung in jedem rekursiven Aufruf. fac(n) : terminiert sofort für n 1, andernfalls wird die Funktion rekursiv mit Parameter < n aufgerufen.
9 Terminierung von rekursiven Funktionsaufrufen Wie bei Schleifen brauchen wir o Fortschritt Richtung Terminierung in jedem rekursiven Aufruf. fac(n) : terminiert sofort für n 1, andernfalls wird die Funktion rekursiv mit Parameter < n aufgerufen. n wird mit jedem Aufruf kleiner.
10 Auswertung rekursiver Funktionsaufrufe (z.b. fac(3)) // POST: return value is n! unsigned int fac (unsigned int n) { if (n <= 1) return 1; return n * fac(n-1); // n > 1
11 Auswertung rekursiver Funktionsaufrufe (z.b. fac(3)) // POST: return value is n! unsigned int fac (unsigned int n) { // n = 3 if (n <= 1) return 1; return n * fac(n-1); // n > 1 Initialisierung des formalen Parameters mit dem Wert des Aufrufparameters
12 Auswertung rekursiver Funktionsaufrufe (z.b. fac(3)) // POST: return value is n! unsigned int fac (unsigned int n) { // n = 3 if (n <= 1) return 1; return n * fac(n-1); // n > 1 Ausführen des Funktionsrumpfs: Auswertung des Rückgabeausdrucks
13 Auswertung rekursiver Funktionsaufrufe (z.b. fac(3)) // POST: return value is n! unsigned int fac (unsigned int n) { // n = 3 if (n <= 1) return 1; return n * fac(n-1); // n > 1 Ausführen des Funktionsrumpfs: Rekursiver Aufruf von fac mit Aufrufparameter n-1 == 2
14 Auswertung rekursiver Funktionsaufrufe (z.b. fac(3)) // POST: return value is n! unsigned int fac (unsigned int n) { // n = 2 if (n <= 1) return 1; return n * fac(n-1); // n > 1 Initialisierung des formalen Parameters mit dem Wert des Aufrufparameters
15 Auswertung rekursiver Funktionsaufrufe (z.b. fac(3)) // POST: return value is n! unsigned int fac (unsigned int n) { // n = 2 if (n <= 1) return 1; return n * fac(n-1); // n > 1 Es gibt jetzt zwei! Den von fac (3), und den von fac (2) Initialisierung des formalen Parameters mit dem Wert des Aufrufparameters
16 Auswertung rekursiver Funktionsaufrufe (z.b. fac(3)) // POST: return value is n! unsigned int fac (unsigned int n) { // n = 2 if (n <= 1) return 1; return n * fac(n-1); // n > 1 Wir nehmen den Parameter des aktuellen Aufrufs, fac (2) Initialisierung des formalen Parameters mit dem Wert des Aufrufparameters
17 Der Aufrufstapel Bei Auswertung jedes Funktionsaufrufs: o Wert des Aufrufparameters kommt auf einen Stapel (erst n = 3, dann n = 2,...) o es wird stets mit dem obersten Wert gearbeitet o nach Ende des Funktionsaufrufs wird der oberste Wert vom Stapel gelöscht
18 Der Aufrufstapel Bei Auswertung jedes Funktionsaufrufs: o Wert des Aufrufparameters kommt auf einen Stapel (erst n = 3, dann n = 2,...) o es wird stets mit dem obersten Wert gearbeitet o nach Ende eines Funktionsaufrufs wird der oberste Wert vom Stapel gelöscht Bei mehreren Parametern analog (alle kommen auf den Stapel, wir arbeiten jeweils mit der obersten Version jedes Parameters)
19 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { if (n <= 1) return 1; return n * fac(n-1); // n > 1
20 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 3 if (n <= 1) return 1; return n * fac(n-1); // n > 1 fac(3) Auswertung von fac(3)beginnt; Aufrufparameter kommt auf Stapel 3
21 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 3 if (n <= 1) return 1; return n * fac(n-1); // n > 1 fac(3) 3
22 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 2 if (n <= 1) return 1; return n * fac(n-1); // n > 1 fac(2) Auswertung von fac(2)beginnt; Aufrufparameter kommt auf Stapel 2 3
23 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 2 if (n <= 1) return 1; return n * fac(n-1); // n > 1 fac(2) 2 3
24 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 1 if (n <= 1) return 1; return n * fac(n-1); // n > 1 Auswertung von fac(1)beginnt; Aufrufparameter kommt auf Stapel fac(1) 1 2 3
25 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 1 if (n <= 1) return 1; return n * fac(n-1); // n > 1 fac(1) 1 2 3
26 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 1 if (n <= 1) return 1; return n * 1 ; // n > 1 fac(2) fac(1) ausgewertet, Ergebnis 1; lösche obersten Wert vom Stapel 2 3
27 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 1 if (n <= 1) return 1; return n * 1 ; // n > 1 fac(2) 2 3
28 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 1 if (n <= 1) return 1; return n * 2 ; // n > 1 fac(3) fac(2) ausgewertet, Ergebnis 2; lösche obersten Wert vom Stapel 3
29 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 1 if (n <= 1) return 1; return n * 2 ; // n > 1 fac(3) 3
30 Der Aufrufstapel - Beispiel // POST: return value is n! unsigned int fac (unsigned int n) { // n = 1 if (n <= 1) return 1; return n * fac(n-1); // n > 1 fac(3) ausgewertet, Ergebnis 6; lösche obersten Wert vom Stapel
31 Grösster gemeinsamer Teiler Euklidischer Algorithmus o findet den grössten gemeinsamen Teiler gcd (a, b) zweier natürlicher Zahlen a und b
32 Grösster gemeinsamer Teiler Euklidischer Algorithmus o findet den grössten gemeinsamen Teiler gcd (a, b) zweier natürlicher Zahlen a und b o basiert auf folgendem Lemma: gcd (a, b) = gcd (b, a mod b) für b > 0.
33 Grösster gemeinsamer Teiler gcd (a, b) = gcd (b, a mod b) für b > 0. Beweis: Sei k Teiler von b. Aus folgt a = (a div b) b + a mod b a / k = (a div b) b / k + (a mod b) / k ganzzahlig!
34 Grösster gemeinsamer Teiler gcd (a, b) = gcd (b, a mod b) für b > 0. Beweis: Sei k Teiler von b. Aus folgt a = (a div b) b + a mod b a / k = (a div b) b / k + (a mod b) / k ganzzahlig! ganzzahlig ganzzahlig
35 Grösster gemeinsamer Teiler gcd (a, b) = gcd (b, a mod b) für b > 0. Beweis: Sei k Teiler von b. Aus folgt a = (a div b) b + a mod b k teilt a genau dann, wenn k auch (a mod b) teilt.
36 Grösster gemeinsamer Teiler gcd (a, b) = gcd (b, a mod b) für b > 0. Beweis: Sei k Teiler von b. Aus folgt a = (a div b) b + a mod b k teilt a genau dann, wenn k auch (a mod b) teilt. k ist gemeinsamer Teiler von a und b genau dann, wenn k gemeinsamer Teiler von a mod b und b ist.
37 Grösster gemeinsamer Teiler // POST: return value is the greatest common // divisor of a and b unsigned int gcd (unsigned int a, unsigned int b) { if (b == 0) return a; return gcd(b, a % b); // b!= 0
38 Grösster gemeinsamer Teiler // POST: return value is the greatest common // divisor of a and b unsigned int gcd (unsigned int a, unsigned int b) { if (b == 0) return a; return gcd(b, a % b); // b!= 0 Korrektheit: gcd (a, 0) = a gcd (a, b) = gcd (b, a mod b), b > 0 Lemma!
39 Grösster gemeinsamer Teiler // POST: return value is the greatest common // divisor of a and b unsigned int gcd (unsigned int a, unsigned int b) { if (b == 0) return a; return gcd(b, a % b); // b!= 0 Terminierung: a mod b < b, also wird b in jedem rekursiven Aufruf kleiner.
40 Grösster gemeinsamer Teiler // POST: return value is the greatest common // divisor of a and b unsigned int gcd (unsigned int a, unsigned int b) { if (b == 0) return a; return gcd(b, a % b); // b!= 0 Korrektheit und Terminierung müssen bei rekursiven Funktionen stets separat bewiesen werden!
41 Fibonacci-Zahlen o F 0 := 0 o F 1 := 1 o F n := F n-1 + F n-2, n > 1
42 Fibonacci-Zahlen o F 0 := 0 o F 1 := 1 o F n := F n-1 + F n-2, n > 1 0, 1, 1, 2, 3, 5, 8, 13, 21,...
43 Fibonacci-Zahlen // POST: return value is the n-th // Fibonacci number F_n unsigned int fib (unsigned int n) { if (n == 0) return 0; if (n == 1) return 1; return fib(n-1) + fib(n-2); // n > 1
44 Fibonacci-Zahlen // POST: return value is the n-th // Fibonacci number F_n unsigned int fib (unsigned int n) { if (n == 0) return 0; if (n == 1) return 1; return fib(n-1) + fib(n-2); // n > 1 Korrektheit und Terminierung sind klar.
45 Fibonacci-Zahlen // POST: return value is the n-th // Fibonacci number F_n unsigned int fib (unsigned int n) { if (n == 0) return 0; if (n == 1) return 1; return fib(n-1) + fib(n-2); // n > 1 Laufzeit:
46 Fibonacci-Zahlen // POST: return value is the n-th // Fibonacci number F_n unsigned int fib (unsigned int n) { if (n == 0) return 0; if (n == 1) return 1; return fib(n-1) + fib(n-2); // n > 1 fib (50) berechnet Laufzeit: F 48 2-mal, F 47 3-mal, F 46 5-mal, F 45 8-mal, F mal,...
47 Rekursion und Iteration Rekursion kann im Prinzip ersetzt werden durch o o Iteration (Schleifen) und expliziten Aufrufstapel. Oft sind direkte rekursive Formulierungen einfacher, aber manchmal auch weniger effizient.
48 Endrekursion Eine Funktion ist endrekursiv, wenn sie genau einen rekursiven Aufruf ganz am Ende enthält.
49 Endrekursion Eine Funktion ist endrekursiv, wenn sie genau einen rekursiven Aufruf ganz am Ende enthält. // POST: return value is the greatest common // divisor of a and b unsigned int gcd (unsigned int a, unsigned int b) { if (b == 0) return a; return gcd(b, a % b); // b!= 0
50 Endrekursion o ist leicht iterativ zu schreiben. // POST: return value is the greatest common divisor of a and b unsigned int gcd2 (unsigned int a, unsigned int b) { while (b!= 0) { unsigned int a_prev = a; a = b; b = a_prev % b; return a;
51 Endrekursion o ist leicht iterativ zu schreiben. // POST: return value is the greatest common divisor of a and b unsigned int gcd2 (unsigned int a, unsigned int b) { while (b!= 0) { unsigned int a_prev = a; a = b; b = a_prev % b; return a; (a,b) := (b, a mod b)
52 Endrekursion o ist leicht iterativ zu schreiben. // POST: return value is the greatest common divisor of a and b unsigned int gcd2 (unsigned int a, unsigned int b) { while (b!= 0) { unsigned int a_prev = a; a = b; b = a_prev % b; return a; (a,b) := (b, a mod b)
53 Endrekursion o ist leicht iterativ zu schreiben. // POST: return value is the greatest common divisor of a and b unsigned int gcd2 (unsigned int a, unsigned int b) { while (b!= 0) { unsigned int a_prev = a; a = b; b = a_prev % b; return a; (a,b) := (b, a mod b)
54 Endrekursion o ist leicht iterativ zu schreiben. // POST: return value is the greatest common divisor of a and b unsigned int gcd2 (unsigned int a, unsigned int b) { while (b!= 0) { unsigned int a_prev = a; a = b; b = a_prev % b; return a; (a,b) := (b, a mod b)...aber die rekursive Version is lesbarer und (fast) genauso effizient.
55 Fibonacci-Zahlen iterativ Idee: o berechne jede Zahl genau einmal, in der Reihenfolge F 0, F 1, F 2, F 3,... o speichere die jeweils letzten beiden berechneten Zahlen (Variablen a, b), dann kann die nächste Zahl durch eine Addition erhalten werden.
56 Fibonacci-Zahlen iterativ // POST: return value is the n-th Fibonacci number F_n unsigned int fib2 (unsigned int n) { if (n == 0) return 0; if (n <= 2) return 1; unsigned int a = 1; // F_1 unsigned int b = 1; // F_2 for (unsigned int i = 3; i <= n; ++i) { unsigned int a_prev = a; // F_{i-2 a = b; // F_{i-1 b += a_prev; // F_{i-1 += F_{i-2 -> F_i return b;
57 Fibonacci-Zahlen iterativ // POST: return value is the n-th Fibonacci number F_n unsigned int fib2 (unsigned int n) { if (n == 0) return 0; if (n <= 2) return 1; unsigned int a = 1; // F_1 unsigned int b = 1; // F_2 for (unsigned int i = 3; i <= n; ++i) { unsigned int a_prev = a; // F_{i-2 a = b; // F_{i-1 b += a_prev; // F_{i-1 += F_{i-2 -> F_i return b; ( F i-2, F i-1 ) := ( F i-1, F i ) a b
58 Die Ackermann-Funktion n + 1, falls m = 0 A (m, n) = A (m-1, 1), falls m > 0, n = 0 A (m-1, A (m, n-1)), falls m > 0, n > 0
59 Die Ackermann-Funktion n + 1, falls m = 0 A (m, n) = A (m-1, 1), falls m > 0, n = 0 A (m-1, A (m, n-1)), falls m > 0, n > 0 o o ist berechenbar, aber nicht primitiv rekursiv (man dachte Anfang des 20. Jahrhunderts, dass es diese Kombination gar nicht gibt) wächst extrem schnell
60 Die Ackermann-Funktion // POST: return value is the Ackermann function // value A(m,n) unsigned int A (unsigned int m, unsigned int n) { if (m == 0) return n+1; if (n == 0) return A(m-1,1); return A(m-1, A(m, n-1));
61 Die Ackermann-Funktion n n+1 m n
62 Die Ackermann-Funktion n n+1 m n n
63 Die Ackermann-Funktion n n+1 m n+2 2n n
64 Die Ackermann-Funktion n n+1 m n+2 2n n n
65 Die Ackermann-Funktion n n+1 m n+2 2n n n Turm von n+3 Zweierpotenzen
66 Die Ackermann-Funktion n n+1 m n+2 2n n n nicht mehr praktisch berechenbar
67 Die Ackermann-Funktion - Moral o Rekursion ist sehr mächtig... o... aber auch gefährlich:
68 Die Ackermann-Funktion - Moral o Rekursion ist sehr mächtig... o... aber auch gefährlich: Es ist leicht, harmlos aussehende rekursive Funktionen hinzuschreiben, die theoretisch korrekt sind und terminieren, praktisch aber jeden Berechenbarkeitsrahmen sprengen.
69 Lindenmayer-Systeme: Zeichnen von Fraktalen (Beispiel für Mächtigkeit der Rekursion)
70 Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, - )
71 Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, - ) o Σ * = Menge aller endlichen Wörter über Σ ( Beispiel: F+F+ ist in Σ * )
72 Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, - ) o Σ * = Menge aller endlichen Wörter über Σ ( Beispiel: F+F+ ist in Σ * ) o P: Σ -> Σ * eine Produktion
73 Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, - ) o Σ * = Menge aller endlichen Wörter über Σ ( Beispiel: F+F+ ist in Σ * ) o P: Σ -> Σ * eine Produktion Beispiel: P(F) = F+F+ P(+) = + P(- ) = -
74 Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, - ) o Σ * = Menge aller endlichen Wörter über Σ ( Beispiel: F+F+ ist in Σ * ) o P: Σ -> Σ * eine Produktion o s aus Σ * ein Startwort ( Beispiel: F)
75 Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, - ) o Σ * = Menge aller endlichen Wörter über Σ ( Beispiel: F+F+ ist in Σ * ) o P: Σ -> Σ * eine Produktion o s aus Σ * ein Startwort ( Beispiel: F) Def.: (Σ, P, s) ist Lindenmayer-System.
76 Lindenmayer-Systeme: Die beschriebenen Wörter Die von (Σ, P, s) beschriebenen Wörter: o s ( F ) o P 1 (s) ( F+F+ ) o P 2 (s) ( F+F++F+F++ ) o o... P 3 (s) ( F+F++F+F+++F+F++F+F+++)
77 Lindenmayer-Systeme: Die beschriebenen Wörter Die von (Σ, P, s) beschriebenen Wörter: o s ( F ) o P 1 (s) ( F+F+ ) o P 2 (s) ( F+F++F+F++ ) o o... P 3 (s) ( F+F++F+F+++F+F++F+F+++) P i (s) entsteht aus P i-1 (s) durch Ersetzen aller Symbole mittels P.
78 Lindenmayer-Systeme: Die beschriebenen Wörter Die von (Σ, P, s) beschriebenen Wörter: o s ( F ) o P 1 (s) ( F+F+ ) o P 2 (s) ( F+F++F+F++ ) o o... P 3 (s) ( F+F++F+F+++F+F++F+F+++) P i (s) entsteht aus P i-1 (s) durch Ersetzen aller Symbole mittels P. F F+F
79 Lindenmayer-Systeme: Turtle-Grafik Turtle-Grafik: o Schildkröte mit Position und Richtung
80 Lindenmayer-Systeme: Turtle-Grafik Turtle-Grafik: o Schildkröte mit Position und Richtung o versteht folgende Kommandos: o o F: gehe einen Schritt in deine Richtung (und markiere ihn in Schwarz) + / - : drehe dich um 90 o gegen / im UZS
81 Lindenmayer-Systeme: Turtle-Grafik Zeichnen eines Wortes : F+F+
82 Lindenmayer-Systeme: Turtle-Grafik Zeichnen eines Wortes : F+F+
83 Lindenmayer-Systeme: Turtle-Grafik Zeichnen eines Wortes : F+F+
84 Lindenmayer-Systeme: Turtle-Grafik Zeichnen eines Wortes : F+F+
85 Lindenmayer-Systeme: Turtle-Grafik Zeichnen eines Wortes : F+F+
86 Lindenmayer-Systeme: Rekursives Zeichnen Zeichnen von w i := P i (s):
87 Lindenmayer-Systeme: Rekursives Zeichnen Zeichnen von w i := P i (s): Im Beispiel: s = F
88 Lindenmayer-Systeme: Die Rekursives Zeichnen Zeichnen von w i := P i (s): o s ( F ) o P 1 (s) ( F+F+ ) o P 2 (s) ( F+F++F+F++ ) o P 3 (s) ( F+F++F+F+++F+F++F+F+++) P 3 (F) P 2 (F) P 2 (+) P 2 (F) P 2 (+)
89 Lindenmayer-Systeme: Die Rekursives Zeichnen Zeichnen von w i := P i (s): o s ( F ) o P 1 (s) ( F+F+ ) o P 2 (s) ( F+F++F+F++ ) o P 3 (s) ( F+F++F+F+++F+F++F+F+++) P 3 (F) P 2 (F) P 2 (+) P 2 (F) P 2 (+) F + F + = P(F)
90 Lindenmayer-Systeme: Die Rekursives Zeichnen Zeichnen von w i := P i (s): o s ( F ) o P 1 (s) ( F+F+ ) o P 2 (s) ( F+F++F+F++ ) o P 3 (s) ( F+F++F+F+++F+F++F+F+++) P 3 (F) P 2 (F) P 2 (+) P 2 (F) P 2 (+) Allgemein: Für alle σ aus Σ gilt: P i (σ) = P i-1 (P(σ)) = P i-1 (σ 1... σ k ) = P i-1 (σ 1 )... P i-1 (σ k )
91 Lindenmayer-Systeme: Die Rekursives Zeichnen Zeichnen von w i := P i (s): o s ( F ) o P 1 (s) ( F+F+ ) o P 2 (s) ( F+F++F+F++ ) o P 3 (s) ( F+F++F+F+++F+F++F+F+++) P 3 (F) P 2 (F) P 2 (+) P 2 (F) P 2 (+) Allgemein: Rekursion! Für alle σ aus Σ gilt: P i (σ) = P i-1 (P(σ)) = P i-1 (σ 1... σ k ) = P i-1 (σ 1 )... P i-1 (σ k )
92 Lindenmayer-Systeme: Rekursives Zeichnen Zeichnen von w i := P i (s): o s = s 1... s k. o w i = P i (s) = P i (s 1...s k ) = P i (s 1 )... P i (s k ) =: w i (s 1 )...w i (s k ) o Zeichnungen der k Wörter w i (s 1 )...w i (s k ) erfolgen rekursiv wie gerade hergeleitet. o Die k Zeichnungen zusammen ergeben w i.
93 Lindenmayer-Systeme: Rekursives Zeichnen (Beispiel) Zeichnen von w i := P i (s): o s = F. o w i = P i (s) = P i (s 1 ) =: w i (s 1 ) = w i (F) o Zeichnung des Wortes w i (F) erfolgt rekursiv wie gerade hergeleitet: w i (F) = w i-1 (F) w i-1 (+) w i-1 (F) w i-1 (+) = w i-1 (F)+w i-1 (F)+
94 Lindenmayer-Systeme: Rekursives Zeichnen (Beispiel) // POST: the word w_i^f is drawn void f (unsigned int i) { if (i == 0) ifm::forward(); // F else { f(i-1); // w_{i-1^f ifm::left(90); // + f(i-1); // w_{i-1^f ifm::left(90); // + w i (F) = w i-1 (F)+w i-1 (F)+
95 Lindenmayer-Systeme: Rekursives Zeichnen (Beispiel) // POST: the word w_i^f is drawn void f (unsigned int i) { if (i == 0) ifm::forward(); // F else { f(i-1); // w_{i-1^f ifm::left(90); // + f(i-1); // w_{i-1^f ifm::left(90); // + Befehle für Turtle-Grafik (aus der libwindow-bibliothek) w i (F) = w i-1 (F)+w i-1 (F)+
96 Lindenmayer-Systeme: Rekursives Zeichnen (Beispiel) Programm lindenmayer.c :
97 Lindenmayer-Systeme: Erweiterungen Neue Symbole (ohne Interpretation in Turtle-Grafik): Beispiel Drachen: o s = X o P(X) = X+YF+, P(Y) = -FX-Y
98 Lindenmayer-Systeme: Erweiterungen (Drachen) // POST: w_i^x is drawn void x (unsigned int i) { if (i > 0) { x(i-1); // w_{i-1^x ifm::left(90); // + y(i-1); // w_{i-1^y ifm::forward(); // F ifm::left(90); // + // POST: w_i^y is drawn void y (unsigned int i) { if (i > 0) { ifm::right(90); // - ifm::forward(); // F x(i-1); // w_{i-1^x ifm::right(90); // - y(i-1); // w_{i-1^y w i (X) = w i-1 (X)+w i-1 (Y)F+ w i (Y) = -w i-1 (F)X-w i-1 (Y)
99 Lindenmayer-Systeme: Drachen Programm dragon.c :
100 Lindenmayer-Systeme: Erweiterungen Drehwinkel α kann frei gewählt werden. Beispiel Schneeflocke: o α = 60 o o s = F++F++F o P(F) = F-F++F-F
101 Lindenmayer-Systeme: Schneeflocke // POST: the word w_i^f is drawn void f (unsigned int i) { if (i == 0) ifm::forward(); // F else { f(i-1); // w_{i-1^f ifm::right(60); // - f(i-1); // w_{i-1^f ifm::left(120); // ++ f(i-1); // w_{i-1^f ifm::right(60); // - f(i-1); // w_{i-1^f w i (F) = w i-1 (F)-w i-1 (F)++w i-1 (F)-w i-1 (F)
102 Lindenmayer-Systeme: Schneeflocke Programm snowflake.c :
Rekursion. Rekursive Funktionen, Korrektheit, Terminierung, Rekursion vs. Iteration, Sortieren
Rekursion Rekursive Funktionen, Korrektheit, Terminierung, Rekursion vs. Iteration, Sortieren Mathematische Rekursion o Viele mathematische Funktionen sind sehr natürlich rekursiv definierbar, d.h. o die
Rekursion. Rekursive Funktionen, Korrektheit, Terminierung, Rekursion vs. Iteration, Sortieren
Rekursion Rekursive Funktionen, Korrektheit, Terminierung, Rekursion vs. Iteration, Sortieren Mathematische Rekursion o Viele mathematische Funktionen sind sehr natürlich rekursiv definierbar, d.h. o die
Lindenmayer-Systeme: Fraktale rekursiv zeichnen. Definition. Definition. Definition. o Alphabet Σ ( Beispiel: {F, +, -} )
Fraktale rekursiv zeichnen Definition o Alphabet Σ ( Beispiel: F, +, - ) Definition o Alphabet Σ ( Beispiel: F, +, - ) o Σ * = Menge aller endlichen Wörter über Σ ( Beispiel: F+F+ ist in Σ * ) Definition
Lindenmayer-Systeme: Fraktale rekursiv zeichnen
Lindenmayer-Systeme: Fraktale rekursiv zeichnen Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} ) Lindenmayer-Systeme: Definition o Alphabet Σ ( Beispiel: {F, +, -} ) o Σ * = Menge aller
2. Algorithmische Methoden 2.1 Rekursion. 18. April 2017
2. Algorithmische Methoden 2.1 Rekursion 18. April 2017 Rekursiver Algorithmus Ein rekursiver Algorithmus löst ein Problem, indem er eine oder mehrere kleinere Instanzen des gleichen Problems löst. Beispiel
Inhalt Kapitel 2: Rekursion
Inhalt Kapitel 2: Rekursion 1 Beispiele und Definition 2 Partialität und Terminierung 3 Formen der Rekursion Endständige Rekursion 4 Einbettung 29 Beispiele und Definition Rekursion 30 Man kann eine Funktion
Einführung in die Informatik I
Einführung in die Informatik I Fortgeschrittene Rekursion Prof. Dr. Nikolaus Wulff Problematische Rekursion Mittels Rekursion lassen sich Spezifikationen recht elegant und einfach implementieren. Leider
Einführung in die Informatik I
Einführung in die Informatik I LOOP Programme, rekursive Funktionen und der Turm von Hanoi Prof. Dr. Nikolaus Wulff Berechenbarkeit Mitte des 20. Jahrhunderts beantworteten Pioniere, wie Alan M. Turing
Speicher und Adressraum
Linearer Speicher (Adressraum) Technische Universität München Speicher und Adressraum Freie Speicherhalde (Heap) Freier Speicherstapel (Stack) Globale Variablen Bibliotheksfunktionen Laufzeitsystem Programmcode
Lösungsvorschlag Serie 2 Rekursion
(/) Lösungsvorschlag Serie Rekursion. Algorithmen-Paradigmen Es gibt verschiedene Algorithmen-Paradigmen, also grundsätzliche Arten, wie man einen Algorithmus formulieren kann. Im funktionalen Paradigma
C++ Teil 4. Sven Groß. 30. Apr IGPM, RWTH Aachen. Sven Groß (IGPM, RWTH Aachen) C++ Teil Apr / 16
C++ Teil 4 Sven Groß IGPM, RWTH Aachen 30. Apr 2015 Sven Groß (IGPM, RWTH Aachen) C++ Teil 4 30. Apr 2015 1 / 16 Themen der letzten Vorlesung Funktionen: Definition und Aufruf Wert- und Referenzparameter,
Informatik I: Einführung in die Programmierung
Informatik I: Einführung in die Programmierung 7. Albert-Ludwigs-Universität Freiburg Bernhard Nebel 31. Oktober 2014 1 31. Oktober 2014 B. Nebel Info I 3 / 20 Um zu, muss man zuerst einmal. Abb. in Public
Algorithmen und Datenstrukturen"
Lehrstuhl für Medieninformatik Universität Siegen Fakultät IV 9 Rekursion Version: WS 14/15 Fachgruppe Medieninformatik 9.1 9 Rekursion... Motivation: Rekursive Formulierung von Algorithmen führt in vielen
4 Rekursionen. 4.1 Erstes Beispiel
4 Rekursionen Viele Algorithmen besitzen sowohl eine iterative als auch eine rekursive Lösung. Sie unterscheiden sich darin, dass die iterative Version meist einen etwas längeren Kode besitzt, während
Algorithmen und Datenstrukturen"
Lehrstuhl für Medieninformatik Universität Siegen Fakultät IV 9 Rekursion Version: WS 14/15 Fachgruppe Medieninformatik 9.1 9 Rekursion... Motivation: Rekursive Formulierung von Algorithmen führt in vielen
Programmieren 1 C Überblick
Programmieren 1 C Überblick 1. Einleitung 2. Graphische Darstellung von Algorithmen 3. Syntax und Semantik 4. Einstieg in C: Einfache Sprachkonstrukte und allgemeiner Programmaufbau 5. Skalare Standarddatentypen
Algorithmen & Programmierung. Rekursive Funktionen (1)
Algorithmen & Programmierung Rekursive Funktionen (1) Berechnung der Fakultät Fakultät Die Fakultät N! einer nichtnegativen ganzen Zahl N kann folgendermaßen definiert werden: d.h. zur Berechnung werden
Rekursive Funktionen
Um Rekursion zu verstehen, muss man vor allem Rekursion verstehen. http://www2.norwalk-city.k12.oh.us/wordpress/precalc/files/2009/05/mona-lisa-jmc.jpg Rekursive Funktionen OOPM, Ralf Lämmel Was ist Rekursion?
GTI. Hannes Diener. 18. Juni. ENC B-0123,
GTI Hannes Diener ENC B-0123, diener@math.uni-siegen.de 18. Juni 1 / 32 Als Literatur zu diesem Thema empfiehlt sich das Buch Theoretische Informatik kurzgefasst von Uwe Schöning (mittlerweile in der 5.
Stand der Vorlesung Komplexität von Algorithmen (Kapitel 3)
Stand der Vorlesung Komplexität von Algorithmen (Kapitel 3) Technische Universität München Motivation: IT gestützte Steuerung, Überwachung, Fertigung, Produktion,. : erfordert effiziente Berechnungsvorschriften
Rekursion. Sie wissen wie man Programme rekursiv entwickelt. Sie kennen typische Beispiele von rekursiven Algorithmen
Rekursion Sie wissen wie man Programme rekursiv entwickelt Sie kennen typische Beispiele von rekursiven Algorithmen Sie kennen die Vor-/Nachteile von rekursiven Algorithmen Einführung 2 von 40 Rekursiver
Rekursive Funktionen
Um Rekursion zu verstehen, muss man vor allem Rekursion verstehen. http://www2.norwalk-city.k12.oh.us/wordpress/precalc/files/2009/05/mona-lisa-jmc.jpg Rekursive Funktionen OOPM, Ralf Lämmel Was ist Rekursion?
( )= c+t(n-1) n>1. Stand der Vorlesung Komplexität von Algorithmen (Kapitel 3)
Stand der Vorlesung Komplexität von Algorithmen (Kapitel 3) Motivation: IT gestützte Steuerung, Überwachung, Fertigung, Produktion,. : erfordert effiziente Berechnungsvorschriften Ziel: Methoden kennen
Aufgabe 1 (12 Punkte)
Aufgabe 1 (12 Punkte) Schreiben Sie eine Klasse public class ZinsesZins, die zu einem gegebenen Anfangskapital von 100,00 die Kapitalentwicklung bei einer jährlichen nachschüssigen Verzinsung in Höhe von
Theoretische Informatik SS 03 Übung 3
Theoretische Informatik SS 03 Übung 3 Aufgabe 1 a) Sind die folgenden Funktionen f : partiell oder total: f(x, y) = x + y f(x, y) = x y f(x, y) = x y f(x, y) = x DIV y? Hierbei ist x DIV y = x y der ganzzahlige
Mathematische Rekursion. Rekursion. Rekursion in C++ Mathematische Rekursion. Definition. 1, falls n 1. n! = n (n-1)!, falls n > 1
Mathematische Rekursio Rekursio o Viele mathematische Fuktioe sid sehr atürlich rekursiv defiierbar, d.h. o die Fuktio erscheit i ihrer eigee Defiitio. Mathematische Rekursio o Viele mathematische Fuktioe
Informatik für Schüler, Foliensatz 18 Rekursion
Prof. G. Kemnitz Institut für Informatik, Technische Universität Clausthal 26. März 2009 1/10 Informatik für Schüler, Foliensatz 18 Rekursion Prof. G. Kemnitz Institut für Informatik, Technische Universität
FHZ. K13 Rekursion. Lernziele. Hochschule Technik+Architektur Luzern Abteilung Informatik, Fach Programmieren. Inhalt
Inhalt 1. Einführung 1. Beispiel: Fakultät 2. Beispiel: Zahlenfolge 3. Beispiel: Formale Sprache 4. Unterschied Iteration/Rekursion 2. Rekursive Methoden 1. Beispiel: Fakultät 2. Beispiel: "Türme
Der euklidische Algorithmus für ganze Zahlen
Der euklidische Algorithmus für ganze Zahlen Ein unverzichtbares Verfahren in der Kryptographie ist der euklidische Algorithmus. In diesem Kapitel stellen wir die erste Version für ganze Zahlen vor. Sei
4 Programmieren in Java III
1 4 Programmieren in Java III 4.1 Rekursive Funktionen und Prozeduren Ein Unterprogramm kann sich selbst aufrufen. Dabei sind, in einer korrekt entworfenen Programmiersprache, die lokalen Variablen der
Typen von Programmiersprachen
Typen von Programmiersprachen Berechenbarkeitstheorie: Formalisierung des intuitiven Berechenbarkeitsbegriffs man kann vier Typen von Programmiersprachen zum Berechnen von Zahlenfunktionen unterscheiden:
LOOP-Programme: Syntaktische Komponenten
LOOP-Programme: Syntaktische Komponenten LOOP-Programme bestehen aus folgenden Zeichen (syntaktischen Komponenten): Variablen: x 0 x 1 x 2... Konstanten: 0 1 2... Operationssymbole: + Trennsymbole: ; :=
Student: Alexander Carls Matrikelnummer: Aufgabe: Beschreibung des euklidischen Algorithmus Datum:
Berufsakademie Stuttgart / Außenstelle Horb Studienbereich Technik Studiengang Informationstechnik Kurs IT2006, 2.Semester Dozent: Olaf Herden Student: Alexander Carls Matrikelnummer: 166270 Aufgabe: Beschreibung
Einführung in die Theoretische Informatik
Technische Universität München Fakultät für Informatik Prof. Tobias Nipkow, Ph.D. Sascha Böhme, Lars Noschinski Sommersemester 2011 Lösungsblatt 9 25. Juli 2011 Einführung in die Theoretische Informatik
Vorsemesterkurs Informatik Übungsaufgaben. Tag 4a - Python
Vorsemesterkurs Informatik Übungsaufgaben Tag 4a - Python Aufgabe 1: Listen Mache dich im Python-Interpreter mit dem Umgang mit Listen vertraut. Kapitel 2.6 im Skript (s.40) enthält nützliche Informationen.
Methoden. Gerd Bohlender. Einstieg in die Informatik mit Java, Vorlesung vom
Einstieg in die Informatik mit Java, Vorlesung vom 2.5.07 Übersicht 1 2 definition 3 Parameterübergabe, aufruf 4 Referenztypen bei 5 Überladen von 6 Hauptprogrammparameter 7 Rekursion bilden das Analogon
Funktionale Programmierung. Funktionale Programmierung: Vorlesungsüberblick. Eigenschaften rein funktionaler Programmierung
Funktionale Programmierung 1 Funktionale Programmierung: Vorlesungsüberblick 1. Funktionale Programmierung Prinzipien funktionaler Programmierung Funktionale Programmierung in prozeduralen Sprachen Rekursive
Institut fu r Informatik
Technische Universita t Mu nchen Institut fu r Informatik Lehrstuhl fu r Bioinformatik Einfu hrung in die Programmierung fu r Bioinformatiker Prof. B. Rost, L. Richter WS 2013/14 Aufgabenblatt 5 2. Dezember
2. Algorithmenbegriff
2. Algorithmenbegriff Keine Algorithmen: Anleitungen, Kochrezepte, Wegbeschreibungen,... Algorithmus: Berechnungsvorschrift, die angibt, wie durch Ausführung bestimmter Elementaroperationen aus Eingabegrößen
Vorkurs Informatik WiSe 17/18
Java Rekursion Dr. Werner Struckmann / Stephan Mielke, Nicole Naczk, 10.10.2017 Technische Universität Braunschweig, IPS Überblick Einleitung Türme von Hanoi Rekursion Beispiele 10.10.2017 Dr. Werner Struckmann
Heap vs. Stack vs. statisch. 6 Speicherorganisation. Beispiel Statische Variablen. Statische Variablen
Heap vs. vs. statisch Der Speicher des Programms ist in verschiedene Speicherbereiche untergliedert Speicherbereiche, die den eigentlichen Programmcode und den Code der Laufzeitbibliothek enthalten; einen
Heap vs. Stack vs. statisch. 6 Speicherorganisation. Beispiel Statische Variablen. Statische Variablen
Heap vs. vs. statisch Der Speicher des Programms ist in verschiedene Speicherbereiche untergliedert Speicherbereiche, die den eigentlichen Programmcode und den Code der Laufzeitbibliothek enthalten; einen
Funktionale Programmierung ALP I. µ-rekursive Funktionen WS 2012/2013. Prof. Dr. Margarita Esponda. Prof. Dr. Margarita Esponda
ALP I µ-rekursive Funktionen WS 2012/2013 Primitiv-rekursive Funktionen Jede primitiv-rekursive Funktion ist Loop-berechenbar. Das bedeutet, dass jede PR-Funktion in der Loop-Programmiersprache formuliert
Beispiel: Fibonacci-Zahlen
Beispiel: Fibonacci-Zahlen Fibonacci Zahlen in der Natur Unendliche Reihe: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,... Fibonacci-Kaninchen: Pinienzapfen Blumenkohl L. P. Fibonacci (1170-1250) G. Zachmann Informatik
Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme
Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme Programmieren I Dr. Werner Struckmann 13. März 2017 Name: Vorname: Matrikelnummer: Kennnummer: Anrede: Frau Herr Studiengang:
Rekursion und Iteration
Rekursion und Iteration Programmieren in Derive Aline Rumöller Rekursion und Iteration Programmieren in Derive IF-Anweisungen in Derive Rekursion Vektorfunktionen in Derive Schleifen in Derive Iteration
Einführung in die Funktionale Programmierung mit Haskell
Einführung in die Funktionale Programmierung mit Haskell Rekursion LFE Theoretische Informatik, Institut für Informatik, Ludwig-Maximilians Universität, München 25. April 2013 Planung Achtung: Nächste
C.3 Funktionen und Prozeduren
C3 - Funktionen und Prozeduren Funktionsdeklarationen in Pascal auch in Pascal kann man selbstdefinierte Funktionen einführen: Funktionen und Prozeduren THEN sign:= 0 Funktion zur Bestimmung des Vorzeichens
II.3.1 Rekursive Algorithmen - 1 -
1. Grundelemente der Programmierung 2. Objekte, Klassen und Methoden 3. Rekursion und dynamische Datenstrukturen 4. Erweiterung von Klassen und fortgeschrittene Konzepte II.3.1 Rekursive Algorithmen -
Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme
Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme Programmieren I Dr. Werner Struckmann 17. Februar 2018 Name: Vorname: Matrikelnummer: Kennnummer: Anrede: Frau Herr
Folgen und Funktionen in der Mathematik
Folgen und Funktionen in der Mathematik Anhand von einigen exemplarischen Beispielen soll die Implementierung von mathematischen Algorithmen in C/C++ gezeigt werden: Reelle Funktionen in C/C++ Diese wird
Übung zur Vorlesung Berechenbarkeit und Komplexität
RWTH Aachen Lehrgebiet Theoretische Informatik Reidl Ries Rossmanith Sanchez Tönnis WS 2012/13 Übungsblatt 7 26.11.2012 Übung zur Vorlesung Berechenbarkeit und Komplexität Aufgabe T15 Entwickeln Sie ein
Programmierkurs Python I
Programmierkurs Python I Michaela Regneri & Stefan Thater Universität des Saarlandes FR 4.7 Allgemeine Linguistik (Computerlinguistik) Winter 2010/11 Übersicht Kurze Wiederholung: while Sammeltypen (kurz
VL-11: LOOP und WHILE Programme I. (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger
VL-11: LOOP und WHILE Programme I (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger WS 2017, RWTH BuK/WS 2017 VL-11: LOOP und WHILE Programme I 1/46 Organisatorisches Nächste Vorlesung: Mittwoch,
12. Felder (Arrays) II. Caesar-Code, Strings, Lindenmayer-Systeme, Mehrdimensionale Felder, Vektoren von Vektoren, Kürzeste Wege
373 12. Felder (Arrays) II Caesar-Code, Strings, Lindenmayer-Systeme, Mehrdimensionale Felder, Vektoren von Vektoren, Kürzeste Wege Caesar-Code 374 Ersetze jedes druckbare Zeichen in einem Text durch seinen
Rekursion. Annabelle Klarl. Einführung in die Informatik Programmierung und Softwareentwicklung
Rekursion Annabelle Klarl Zentralübung zur Vorlesung Einführung in die Informatik: http://www.pst.ifi.lmu.de/lehre/wise-12-13/infoeinf WS12/13 Aufgabe 1: Potenzfunktion Schreiben Sie eine Methode, die
Technische Informatik 1 Übung 2 Assembler (Rechenübung) Georgia Giannopoulou (ggeorgia@tik.ee.ethz.ch) 22./23. Oktober 2015
Technische Informatik 1 Übung 2 Assembler (Rechenübung) Georgia Giannopoulou (ggeorgia@tik.ee.ethz.ch) 22./23. Oktober 2015 Ziele der Übung Aufgabe 1 Aufbau und Aufruf von Funktionen in Assembler Codeanalyse
Beispiel 1: Fakultät
16. Rekursion Beispiel 1: Fakultät Rekursive Definition der Fakultät (Mathematik) n! = 1 falls n=0 n*(n-1)! falls n>0 Programmierung mittels einer rekursiven Funktion in C++ double fakultaet(int n) if
Wiederholung. Organisatorisches. VL-11: LOOP und WHILE Programme I. (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger
Organisatorisches VL-11: LOOP und WHILE Programme I (Berechenbarkeit und Komplexität, WS 2017) Gerhard Woeginger Nächste Vorlesung: Mittwoch, November 29, 14:15 15:45 Uhr, Roter Hörsaal Webseite: http://algo.rwth-aachen.de/lehre/ws1718/buk.php
Die erste C++ Funktion
Die erste C++ Funktion Funktion zur Potenzberechnung // PRE: e >= 0 b!= 0.0 // POST: return value is b^e double pow (double b, int e) { double result = 1.0; if (e < 0) { // b^e = (1/b)^(-e) b = 1.0/b;
p Z >1 ist Primzahl, wenn gilt Euklid:
Grundlegende Tatsachen über den Ring Z Z; +, ist ein nullteilerfreier Ring Divisionseigenschaft a Z, b Z > q, r Z : a = b q + r, r < b Arithmetik Grundlegende Tatsachen über den Ring Z Euklidischer Algorithmus
Funktionale Programmierung ALP I. Die Natur rekursiver Funktionen SS Prof. Dr. Margarita Esponda. Prof. Dr.
ALP I Die Natur rekursiver Funktionen SS 2011 Die Natur rekursiver Funktionen Rekursive Funktionen haben oft folgende allgemeine Form: f :: a -> a f 0 = c f (n+1) = h (f n ) Diese Art der Definitionen
Grundlagen Theoretischer Informatik 2 WiSe 2011/12 in Trier. Henning Fernau Universität Trier
Grundlagen Theoretischer Informatik 2 WiSe 2011/12 in Trier Henning Fernau Universität Trier fernau@uni-trier.de 1 Grundlagen Theoretischer Informatik 2 Gesamtübersicht Organisatorisches; Einführung Ersetzungsverfahren:
{P} S {Q} {P} S {Q} {P} S {Q} Inhalt. Hoare-Kalkül. Hoare-Kalkül. Hoare-Tripel. Hoare-Tripel. Hoare-Tripel
Inhalt Hoare-Kalkül Formale Verifizierung Hoare-Kalkül while-sprache Terminierung Partielle / totale Korrektheit 4.0 Hoare-Kalkül entwickelt von C.A.R. (Tony) Hoare (britischer Informatiker), 1969 formales
Einführung in die Informatik 1
Einführung in die Informatik 1 Algorithmen und algorithmische Sprachkonzepte Sven Kosub AG Algorithmik/Theorie komplexer Systeme Universität Konstanz E 202 Sven.Kosub@uni-konstanz.de Sprechstunde: Freitag,
Informatik I Rekursion
Informatik I Rekursion G. Zachmann Clausthal University, Germany zach@in.tu-clausthal.de Motivation Neue Denkweise eistungsfähiges Algorithmenschema Divide-and-conquer Viele Berechnungen und Datenstrukturen
Abschlussklausur. Lösung
Übungen zur Vorlesung Informatik für Informationsmanager WS 2005/2006 Universität Koblenz-Landau Institut für Informatik Prof. Dr. Bernhard Beckert Dr. Manfred Jackel Abschlussklausur 02.03.2006 Lösung
Rekursive Funktionen (1)
Rekursive Funktionen (1) Rekursive Algorithmen Wenn Gesamtlösung durch Lösen gleichartiger Teilprobleme erzielbar: Rekursion möglich Beispiel: Fakultät einer ganzen Zahl n: n i n! = i=1 für n > 0 1 für
2. Teilbarkeit. Euklidischer Algorithmus
O. Forster: Einführung in die Zahlentheorie 2. Teilbarkeit. Euklidischer Algorithmus 2.1. Wir benutzen die folgenden Bezeichnungen: Z = {0, ±1, ±2, ±3,...} Menge aller ganzen Zahlen N 0 = {0, 1, 2, 3,...}
Mächtigkeit von WHILE-Programmen
Mächtigkeit von WHILE-Programmen Prof. Dr. Berthold Vöcking Lehrstuhl Informatik 1 Algorithmen und Komplexität RWTH Aachen 1 / 23 Turingmaschine (TM) M = (Q, Σ, Γ, B, q 0, q, δ) Unendliches Band... 0 c
Beispiel: Fibonacci-Zahlen
Beispiel: Fibonacci-Zahlen Unendliche Reihe: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34,... Fibonacci-Kaninchen: L. P. Fibonacci (1170-1250) G. Zachmann Informatik 1 - WS 05/06 Rekursion 23 Fibonacci Zahlen in der
12. Rekursion Grundlagen der Programmierung 1 (Java)
12. Rekursion Grundlagen der Programmierung 1 (Java) Fachhochschule Darmstadt Haardtring 100 D-64295 Darmstadt Prof. Dr. Bernhard Humm FH Darmstadt, 24. Januar 2006 Einordnung im Kontext der Vorlesung
Algorithmen und Datenstrukturen 1. EINLEITUNG. Algorithmen und Datenstrukturen - Ma5hias Thimm 1
Algorithmen und Datenstrukturen 1. EINLEITUNG Algorithmen und Datenstrukturen - Ma5hias Thimm (thimm@uni-koblenz.de) 1 Allgemeines Einleitung Zu den Begriffen: Algorithmen und Datenstrukturen systematische
Algorithmen und Datenstrukturen
Algorithmen und Datenstrukturen Tafelübung 06 Grammatiken, Backus-Naur-Form, Rekursion Clemens Lang T2 1. Juni 2010 14:00 16:00, 00.152 Tafelübung zu AuD 1/20 Aufbau und Begriffe Grammatiken Struktur einer
Grundlagen der Programmierung
Grundlagen der Programmierung Algorithmen und Datenstrukturen Die Inhalte der Vorlesung wurden primär auf Basis der angegebenen Literatur erstellt. Darüber hinaus sind ausgewählte Teile in Anlehnung an
Abschnitt 11: Korrektheit von imperativen Programmen
Abschnitt 11: Korrektheit von imperativen Programmen 11. Korrektheit von imperativen Programmen 11.1 11.2Testen der Korrektheit in Java Peer Kröger (LMU München) in die Programmierung WS 16/17 931 / 961
Vorlesung Programmieren
Vorlesung Programmieren 11 Rekursion Jun.-Prof. Dr.-Ing. Anne Koziolek Version 1.1 ARBEITSGRUPPE ARCHITECTURE-DRIVEN REQUIREMENTS ENGINEERING (ARE) INSTITUT FÜR PROGRAMMSTRUKTUREN UND DATENORGANISATION
Kapitel 5: Abstrakte Algorithmen und Sprachkonzepte. Elementare Schritte
Elementare Schritte Ein elementarer Berechnungsschritt eines Algorithmus ändert im Allgemeinen den Wert von Variablen Zuweisungsoperation von fundamentaler Bedeutung Zuweisungsoperator In Pascal := In
Einführung in die Programmierung Wintersemester 2017/18
Einführung in die Programmierung Wintersemester 2017/18 Prof. Dr. Günter Rudolph Lehrstuhl für Algorithm Engineering Fakultät für Informatik TU Dortmund : Rekursion Inhalt Rekursion: Technik Rekursion
Einführung in die Programmierung Wintersemester 2010/11
Einführung in die Programmierung Wintersemester 2010/11 Prof. Dr. Günter Rudolph Lehrstuhl für Algorithm Engineering Fakultät für Informatik TU Dortmund : Rekursion Inhalt Rekursion: Technik Rekursion
Übersicht. Datenstrukturen und Algorithmen Vorlesung 5: Rekursionsgleichungen (K4) Übersicht. Binäre Suche. Joost-Pieter Katoen. 20.
Übersicht Datenstrukturen und Algorithmen Vorlesung 5: (K4) Joost-Pieter Katoen Lehrstuhl für Informatik 2 Software Modeling and Verification Group http://www-i2.informatik.rwth-aachen.de/i2/dsal12/ 20.
Prof. Dr. Oliver Haase Karl Martin Kern Achim Bitzer. Programmiertechnik Klassenmethoden Teil 2
Prof. Dr. Oliver Haase Karl Martin Kern Achim Bitzer Programmiertechnik Klassenmethoden Teil 2 Rekursion 2/23 Definition Rekursion, die siehe Rekursion Was ist Rekursion Allgemein: Rekursion ist die Definition
Einstieg in die Informatik mit Java
1 / 26 Einstieg in die Informatik mit Java Methoden Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 26 1 Methoden 2 Methodendefinition 3 Parameterübergabe, Methodenaufruf
Grundlagen der Programmierung 2 (1.B)
Grundlagen der Programmierung 2 (1.B) Prof. Dr. Manfred Schmidt-Schauß Künstliche Intelligenz und Softwaretechnologie 20. April 2011 Aufrufhierarchie und Rekursive Definitionen f, g, f i seien Haskell-definierte
Klassenvariablen, Klassenmethoden
Einstieg in die Informatik mit Java, Vorlesung vom 11.12.07 Übersicht 1 Klassenmethoden 2 Besonderheiten von Klassenmethoden 3 Aufruf einer Klassenmethode 4 Hauptprogrammparameter 5 Rekursion Klassenmethoden
Grundlagen der Programmierung in C Funktionen
Der erste Mechanismus für Code-Reuse! Grundlagen der Programmierung in C Funktionen Wintersemester 2005/2006 G. Zachmann Clausthal University, Germany zach@in.tu-clausthal.de Ältester Mechanismus für Code-Reuse:
Rekursion. L. Piepmeyer: Funktionale Programmierung - Rekursion
Rekursion 1 Iterative und rekursive Methoden Summe von 1 bis n berechnen: iterativ rekursiv public int sum(int n){ int result = 0; for(int i=1; i
Programmieren I. Methoden-Spezial Heusch --- Ratz 6.1, Institut für Angewandte Informatik
Programmieren I Methoden-Spezial Heusch --- Ratz 6.1, 6.2 KIT Die Forschungsuniversität in der Helmholtz-Gemeinschaft www.kit.edu Parameterübergabe bei primitivem Datentypen (Wertkopie) public class MethodParameters
Einstieg in die Informatik mit Java
1 / 20 Einstieg in die Informatik mit Java Rekursion Gerd Bohlender Institut für Angewandte und Numerische Mathematik Gliederung 2 / 20 1 Überblick 2 Rekursion 3 Rekursive Sortieralgorithmen 4 Backtracking
Inhalt Kapitel 3: Induktion und Termination
Inhalt Kapitel 3: Induktion und Termination 1 Wohlfundierte Relationen Ackermannfunktion 2 Untere Schranke für Türme von Hanoi Weitere Beispiele 52 Wohlfundierte Relationen Wohlfundierte Relationen Definition
Rekursion. Annabelle Klarl. Einführung in die Informatik Programmierung und Softwareentwicklung
Annabelle Klarl Zentralübung zur Vorlesung Einführung in die Informatik: http://www.pst.ifi.lmu.de/lehre/wise-13-14/infoeinf WS13/14 Action required now 1. Smartphone: installiere die App "socrative student"
Praktische Informatik I - Algorithmen und Datenstrukturen Wintersemester 2006/ Algorithmen und ihre formalen Eigenschaften, Datenstrukturen
1 Grundlagen 1.1 Algorithmen und ihre formalen Eigenschaften, Datenstrukturen Ein Algorithmus ist ein mit formalen Mitteln beschreibbares, mechanisch nachvollziehbares Verfahren zur Lösung einer Klasse
Vortrag 20: Kurze Vektoren in Gittern
Seminar: Wie genau ist ungefähr Vortrag 20: Kurze Vektoren in Gittern Kerstin Bauer Sommerakademie Görlitz, 2007 Definition und Problembeschreibung Definition: Gitter Seien b 1,,b k Q n. Dann heißt die
Objektorientierte Programmierung (ZQ1u2B)
Objektorientierte Programmierung (ZQ1u2B) Woche 4 Rekursion Christopher Scho lzel Technische Hochschule Mittelhessen 4. November 2015 Inhalt Rekursion Lineare Rekursion Verzweigte Rekursion Verschränkte
! 1. Erste Schritte! 2. Einfache Datentypen! 3. Anweisungen und Kontrollstrukturen! 4. Verifikation! 5. Reihungen (Arrays) II.1.4. Verifikation - 1 -
! 1. Erste Schritte! 2. Einfache Datentypen! 3. Anweisungen und Kontrollstrukturen! 4. Verifikation! 5. Reihungen (Arrays) II.1.4. Verifikation - 1 - 4. Verifikation! Spezifikation: Angabe, was ein Programm
Vorkurs Informatik WiSe 16/17
Java Rekursion Dr. Werner Struckmann / Stephan Mielke, Jakob Garbe, 11.10.2016 Technische Universität Braunschweig, IPS Überblick Einleitung Beispiele 11.10.2016 Dr. Werner Struckmann / Stephan Mielke,
Einführung in die Informatik für Naturwissenschaftler und Ingenieure (alias Einführung in die Programmierung)
Wintersemester 2007/08 Einführung in die Informatik für Naturwissenschaftler und Ingenieure (alias Einführung in die Programmierung) (Vorlesung) Prof. Dr. Günter Rudolph Fakultät für Informatik Lehrstuhl
Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme
Technische Universität Braunschweig Institut für Programmierung und Reaktive Systeme Programmieren I Dr. Werner Struckmann 12. März 2014 Name: Vorname: Matrikelnummer: Kennnummer: Anrede: Frau Herr Studiengang:
Prof. Dr. Margarita Esponda
Die O-Notation Analyse von Algorithmen Die O-Notation Prof. Dr. Margarita Esponda Freie Universität Berlin ALP II: Margarita Esponda, 5. Vorlesung, 26.4.2012 1 Die O-Notation Analyse von Algorithmen Korrektheit
2. Imperative Programmierung und Berechenbarkeit - Registermaschinen -
2. Imperative Programmierung und Berechenbarkeit - Registermaschinen - 2.1 Definition 2.2 Loop-Programme 2.3 While Programme 2.4 While Programme und rekursive Funktionen Im Wesentlichen: Tafel! Maschinenmodell