9. Rekursion - lec.inf.ethz.ch · Die Turme¨ von Hanoi - Rekursiver Losungsansatz¨ Links Mitte...

9. Rekursion

Mathematische Rekursion, Terminierung, der Aufrufstapel,Beispiele, Rekursion vs. Iteration

Experiment: Die Turme von Hanoi

Links Mitte Rechts

Experiment: Die Turme von Hanoi

Links Mitte Rechts

Die Turme von Hanoi - So gehts!

Links Mitte Rechts

Die Turme von Hanoi - Rekursiver Losungsansatz

Links Mitte Rechts

Mal angenommen, wirwüssten wie man ...

... drei Scheiben von einemStapel zum anderen bringt ...... dann ist es sehr einfach!

... und hopp!

Links Mitte Rechts

... und hopp!

Links Mitte Rechts

... drei Scheiben von einemStapel zum anderen bringt ...

... dann ist es sehr einfach!

... und hopp!

Links Mitte Rechts

... drei Scheiben von einemStapel zum anderen bringt ...

... und hopp!

Links Mitte Rechts

... und hopp!

Links Mitte Rechts

... und hopp!

Links Mitte Rechts

Doch wie können wir dreiScheiben bewegen?

... zwei Scheiben von einemStapel zum anderen bringt ...

Links Mitte Rechts

Doch wie können wir zweiScheiben bewegen?

Wir wissen, wie man ...

... eine Scheiben von einemStapel zum anderen bringt!

Alles einfach! Der Restgeht im gleichen Stilweiter...

Links Mitte Rechts

Mathematische Rekursion

Viele mathematische Funktionen sind sehr natürlich rekursivdefinierbar.

Das heisst, die Funktion erscheint in ihrer eigenen Definition.

{1, falls n ≤ 1

n · (n− 1)!, andernfalls

Mathematische Rekursion

Viele mathematische Funktionen sind sehr natürlich rekursivdefinierbar.Das heisst, die Funktion erscheint in ihrer eigenen Definition.

{1, falls n ≤ 1

Rekursion in Java: Genauso!

{1 falls n ≤ 1

public static int fakultaet ( int n) {if (n <= 1) {

return 1;} else {

return n ∗ fakultaet (n−1);}

n!⇔ fakultaet(n)n− 1!⇔ fakultaet(n−1)

Rekursion in Java: Genauso!

{1 falls n ≤ 1

public static int fakultaet ( int n) {if (n <= 1) {

return 1;} else {

return n ∗ fakultaet (n−1);}

n!⇔ fakultaet(n)n− 1!⇔ fakultaet(n−1)

Unendliche Rekursion

ist so schlecht wie eine Endlosschleife. . .

. . . nur noch schlimmer (“verbrennt” Zeit und Speicher)

Beispiel: f()→ f()→ f()→ f()→ . . . stack overflow

public static void f () {f ();

Mir san mir.

Bayerisches Lebensmotto

ist so schlecht wie eine Endlosschleife. . .. . . nur noch schlimmer (“verbrennt” Zeit und Speicher)

Mir san mir.

Bayerisches Lebensmotto204

Rekursive Funktionen: Terminierung

Wie bei Schleifen brauchen wir

Fortschritt Richtung Terminierung

fakultaet(n)terminiert sofort für n ≤ 1, andernfalls wird die Funktion rekursiv mitArgument < n aufgerufen.

“n wird mit jedem Aufruf kleiner.”

Rekursive Funktionen: Auswertung

Beispiel: fakultaet(4)

public static int fakultaet (int n){

if (n <= 1) return 1;return n * fakultaet(n-1); // n > 1

Aufruf von fakultaet(4)

public static int fakultaet (int n){// n = 4if (n <= 1) return 1;return n * fakultaet(n-1); // n > 1

Initialisierung des formalen Arguments

Auswertung des Rückgabeausdrucks

Rekursiver Aufruf mit Argument n− 1, also 3

Es gibt jetzt zwei n. Das von fac(4) und das von fac(3)

public static int fakultaet (int n){

if (n <= 1) return 1;return n * fakultaet(n-1); // n > 1

Es wird mit dem n des aktuellen Aufrufs gearbeitet: n = 3

Der Aufrufstapel

Bei jedem Funktionsaufruf:

Wert des Aufrufarguments kommt aufeinen Stapel

Es wird immer mit dem obersten Wertgearbeitet

Am Ende des Aufrufs wird der obersteWert wieder vom Stapel gelöscht

System.out.println(fakultaet(4))

n = 1n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

Der Aufrufstapel

n = 1n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

fakultaet(4)

Der Aufrufstapel

n = 1n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

fakultaet(4)

fakultaet(3)

Der Aufrufstapel

n = 1n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

fakultaet(4)

fakultaet(3)

fakultaet(2)

Der Aufrufstapel

n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

fakultaet(4)

fakultaet(3)

fakultaet(2)

fakultaet(1)

Der Aufrufstapel

n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

fakultaet(4)

fakultaet(3)

fakultaet(2)

fakultaet(1) 1

Der Aufrufstapel

n = 1n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

fakultaet(4)

fakultaet(3)

fakultaet(2) 2

Der Aufrufstapel

n = 1n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

fakultaet(4)

fakultaet(3) 6

Der Aufrufstapel

n = 1n = 1 1! = 1

n = 2 2 · 1! = 2

n = 3 3 · 2! = 6

n = 4 4 · 3! = 24

fakultaet(4) 24

Euklidischer Algorithmus

findet den grössten gemeinsamen Teiler gcd(a, b) zweiernatürlicher Zahlen a und b

basiert auf folgender mathematischen Rekursion:

gcd(a, b) =

{a, falls b = 0

gcd(b, a mod b), andernfalls

Euklidischer Algorithmus

findet den grössten gemeinsamen Teiler gcd(a, b) zweiernatürlicher Zahlen a und bbasiert auf folgender mathematischen Rekursion:

gcd(a, b) =

{a, falls b = 0

Euklidischer Algorithmus in Java

gcd(a, b) =

{a, falls b = 0

public static int gcd(int a, intb){if (b == 0) {

return a;} else {

return gcd(b, a%b);}

Euklidischer Algorithmus in Java

gcd(a, b) =

{a, falls b = 0

public static int gcd(int a, intb){if (b == 0) {

return a;} else {

return gcd(b, a%b);}

Terminierung: a mod b < b, alsowird b in jedem rekursiven Aufrufkleiner.

Fibonacci-Zahlen

0, falls n = 0

1, falls n = 1

Fn−1 + Fn−2, falls n > 1

Resultat: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 . . .

Fibonacci-Zahlen

0, falls n = 0

1, falls n = 1

Resultat: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89 . . .

Fibonacci-Zahlen in Zurich

Fibonacci-Zahlen in Java

0, falls n = 0

1, falls n = 1

public static int fib (int n){if (n == 0 || n == 1){

return n;} else {

return fib (n−1) + fib(n−2);}

0, falls n = 0

1, falls n = 1

return n;} else {

Korrektheit und Terminierungsind klar, aber...

Laufzeitfib(50) dauert „ewig”, denn es berechnetF48 2-mal, F47 3-mal, F46 5-mal, F45 8-mal, F44 13-mal,F43 21-mal ... F1 ca. 109 mal (!)

return n;} else {

Schnelle Fibonacci-Zahlen

Berechne jede Fibonacci-Zahl nur einmal, in der ReihenfolgeF0, F1, F2, . . . , Fn!

Merke dir jeweils die zwei letzten berechneten Zahlen (Variablen aund b)!Berechne die nächste Zahl als Summe von a und b!

Berechne jede Fibonacci-Zahl nur einmal, in der ReihenfolgeF0, F1, F2, . . . , Fn!Merke dir jeweils die zwei letzten berechneten Zahlen (Variablen aund b)!

Berechne die nächste Zahl als Summe von a und b!

Berechne jede Fibonacci-Zahl nur einmal, in der ReihenfolgeF0, F1, F2, . . . , Fn!Merke dir jeweils die zwei letzten berechneten Zahlen (Variablen aund b)!Berechne die nächste Zahl als Summe von a und b!

Schnelle Fibonacci-Zahlen in Java

public static int fib (int n)\{if (n == 0) return 0;if (n <= 2) return 1;int a = 1; // F(1)int b = 1; // F(2)for ( int i = 3; i <= n; ++i){

int a_old = a; // F(i−2)a = b; // F(i−1)b += a_old; // F(i−1) += F(i−2) −> F(i)

}return b;

10. Suchen

Das Suchproblem

Gegeben

Menge von Datensätzen.

BeispieleTelefonverzeichnis, Wörterbuch, Symboltabelle

Jeder Datensatz hat einen Schlüssel k.Schlüssel sind vergleichbar: eindeutige Antwort auf Frage k1 ≤ k2für Schlüssel k1, k2.

Aufgabe: finde Datensatz nach Schlüssel k.

Suche in Array

Gegeben

Array A mit n Elementen (A[1], . . . , A[n]).Schlüssel b

Gesucht: Index k, 1 ≤ k ≤ n mit A[k] = b oder ”nicht gefunden”.

Lineare Suche

Durchlaufen des Arrays von A[1] bis A[n].

Bestenfalls 1 Vergleich.Schlimmstenfalls n Vergleiche.Annahme: Jede Anordnung der n Schlüssel istgleichwahrscheinlich. Erwartete Anzahl Vergleiche:

n∑i=1

i =n+ 1

Lineare Suche

Bestenfalls 1 Vergleich.

Schlimmstenfalls n Vergleiche.Annahme: Jede Anordnung der n Schlüssel istgleichwahrscheinlich. Erwartete Anzahl Vergleiche:

n∑i=1

i =n+ 1

Lineare Suche

Bestenfalls 1 Vergleich.Schlimmstenfalls n Vergleiche.

Annahme: Jede Anordnung der n Schlüssel istgleichwahrscheinlich. Erwartete Anzahl Vergleiche:

n∑i=1

i =n+ 1

Lineare Suche

n∑i=1

i =n+ 1

Lineare Suche

n∑i=1

i =n+ 1

Lineare Suche

n∑i=1

i =n+ 1

Suche in sortierten Array

Gegeben

Sortiertes Array A mit n Elementen (A[1], . . . , A[n]) mitA[1] ≤ A[2] ≤ · · · ≤ A[n].Schlüssel b

Gesucht: Index k, 1 ≤ k ≤ n mit A[k] = b oder ”nicht gefunden”.

Divide and Conquer!Suche b = 23.

b < 28

b > 20

b > 22

b < 24

erfolglos

b < 28

b > 20

b > 22

b < 24

erfolglos

b < 28

b > 20

b > 22

b < 24

erfolglos

b < 28

b > 20

b > 22

b < 24

erfolglos

b < 28

b > 20

b > 22

b < 24

erfolglos

b < 28

b > 20

b > 22

b < 24

erfolglos

b < 28

b > 20

b > 22

b < 24

erfolglos

Binarer Suchalgorithmus BSearch(A,b,l,r)

Input : Sortiertes Array A von n Schlusseln. Schlussel b. Bereichsgrenzen1 ≤ l ≤ r ≤ n oder l > r beliebig.

Output : Index des gefundenen Elements. 0, wenn erfolglos.m← b(l + r)/2cif l > r then // erfolglose Suche

return 0else if b = A[m] then// gefunden

return melse if b < A[m] then// Element liegt links

return BSearch(A, b, l,m− 1)else // b > A[m]: Element liegt rechts

return BSearch(A, b,m+ 1, r)

Analyse (Schlimmster Fall)Rekurrenz (n = 2k)

T (n) =

{d falls n = 1,T (n/2) + c falls n > 1.

Teleskopieren:

T (n) = T(n

)+ i · c

= T(nn

)+ log2 n · c.

⇒ Annahme: T (n) = d+ c log2 n

T (n) =

Teleskopieren:

T (n) = T(n

)+ c = T

)+ i · c

= T(nn

)+ log2 n · c.

T (n) =

Teleskopieren:

T (n) = T(n

)+ c = T

)+ i · c

= T(nn

)+ log2 n · c.

T (n) =

Teleskopieren:

T (n) = T(n

)+ c = T

)+ i · c

= T(nn

)+ log2 n · c.

T (n) =

Teleskopieren:

T (n) = T(n

)+ c = T

)+ i · c

= T(nn

)+ log2 n · c.

⇒ Annahme: T (n) = d+ c log2 n222

Analyse (Schlimmster Fall)

T (n) =

Vermutung : T (n) = d+ c · log2 n

Beweis durch Induktion:

Induktionsanfang: T (1) = d.Hypothese: T (n/2) = d+ c · log2 n/2

Schritt (n/2→ n)

T (n) = T (n/2) + c = d+ c · (log2 n− 1) + c = d+ c log2 n.

Resultat

TheoremDer Algorithmus zur binären sortierten Suche benötigt Θ(log n)Elementarschritte.

Iterativer binarer Suchalgorithmus

Input : Sortiertes Array A von n Schlusseln. Schlussel b.Output : Index des gefundenen Elements. 0, wenn erfolglos.l← 1; r ← nwhile l ≤ r do

m← b(l + r)/2cif A[m] = b then

return melse if A[m] < b then

l← m+ 1else

r ← m− 1

return 0;

Korrektheit

Algorithmus bricht nur ab, falls A leer oder b gefunden.

Invariante: Falls b in A, dann im Bereich A[l, ..., r]

Beweis durch Induktion

Induktionsanfang: b ∈ A[1, .., n] (oder nicht)Hypothese: Invariante gilt nach i SchrittenSchritt:b < A[m]⇒ b ∈ A[l, ..,m− 1]b > A[m]⇒ b ∈ A[m+ 1, .., r]

11. Auswahlen

Min und Max

? Separates Finden von Minimum und Maximum in(A[1], . . . , A[n]) benötigt insgesamt 2n Vergleiche. (Wie) geht es mitweniger als 2n Vergleichen für beide gemeinsam?

! Es geht mit 32N Vergleichen: Vergleiche jeweils 2 Elemente und

deren kleineres mit Min und grösseres mit Max.

Min und Max

? Separates Finden von Minimum und Maximum in(A[1], . . . , A[n]) benötigt insgesamt 2n Vergleiche. (Wie) geht es mitweniger als 2n Vergleichen für beide gemeinsam?

! Es geht mit 32N Vergleichen: Vergleiche jeweils 2 Elemente und

deren kleineres mit Min und grösseres mit Max.

Das Auswahlproblem

Eingabe

Unsortiertes Array A = (A1, . . . , An) paarweise verschiedenerWerteZahl 1 ≤ k ≤ n.

Ausgabe: A[i] mit |{j : A[j] < A[i]}| = k − 1

Spezialfällek = 1: Minimum: Algorithmus mit n Vergleichsoperationen trivial.k = n: Maximum: Algorithmus mit n Vergleichsoperationen trivial.k = bn/2c: Median.

Ansatze

Wiederholt das Minimum entfernen / auslesen: O(k · n).Median: O(n2)

Sortieren (kommt bald): O(n log n)

Pivotieren O(n) !

Ansatze

Pivotieren O(n) !

Ansatze

Pivotieren O(n) !

Ansatze

Pivotieren O(n) !

Pivotieren

1 Wähle ein Element p als Pivotelement2 Teile A in zwei Teile auf, den Rang von p bestimmend.3 Rekursion auf dem relevanten Teil. Falls k = r, dann gefunden.

Pivotieren

1 Wähle ein Element p als Pivotelement

2 Teile A in zwei Teile auf, den Rang von p bestimmend.3 Rekursion auf dem relevanten Teil. Falls k = r, dann gefunden.

Pivotieren

1 Wähle ein Element p als Pivotelement2 Teile A in zwei Teile auf, den Rang von p bestimmend.

3 Rekursion auf dem relevanten Teil. Falls k = r, dann gefunden.

> ≤ ≤ > > ≤ ≤ > ≤p

Pivotieren

>≤ ≤ > >≤ ≤ >≤p

Pivotieren

>≤ ≤ > >≤ ≤ >≤p p≤

Pivotieren

1 Wähle ein Element p als Pivotelement2 Teile A in zwei Teile auf, den Rang von p bestimmend.3 Rekursion auf dem relevanten Teil. Falls k = r, dann gefunden.

>≤ ≤ > >≤ ≤ >≤p p≤

Algorithmus Partition(A[l..r], p)

Input : Array A, welches den Sentinel p im Intervall [l, r] mindestens einmal enthalt.Output : Array A partitioniert in [l..r] um p. Ruckgabe der Position von p.while l < r do

while A[l] < p dol← l + 1

while A[r] > p dor ← r − 1

swap(A[l], A[r])if A[l] = A[r] then

l← l + 1

return l-1

Korrektheit: Invariante

Invariante I: Ai ≤ p ∀i ∈ [0, l), Ai > p ∀i ∈ (r, n], ∃k ∈ [l, r] : Ak = p.while l < r do

while A[l] < p dol← l + 1

l← l + 1

return l-1

I und A[l] ≥ p

I und A[r] ≤ pI und A[l] ≤ p ≤ A[r]

Korrektheit: Fortschritt

while l < r dowhile A[l] < p do

l← l + 1

return l-1

Fortschritt wenn A[l] < p

Fortschritt wenn A[r] > p

Fortschritt wenn A[l] > p oder A[r] < p

Fortschritt wenn A[l] = A[r] = p

Wahl des PivotsDas Minimum ist ein schlechter Pivot: worst Case Θ(?)

Ein guter Pivot hat linear viele Elemente auf beiden Seiten.

≥ ε · n ≥ ε · n

p1 p2 p3

≥ ε · n ≥ ε · n

p1 p2 p3 p4

≥ ε · n ≥ ε · n

Wahl des PivotsDas Minimum ist ein schlechter Pivot: worst Case Θ(n2)

p1 p2 p3 p4 p5

≥ ε · n ≥ ε · n

Wahl des PivotsDas Minimum ist ein schlechter Pivot: worst Case Θ(n2)

p1 p2 p3 p4 p5

≥ ε · n ≥ ε · n

AnalyseUnterteilung mit Faktor q (0 < q < 1): zwei Gruppen mit q · n und(1− q) · n Elementen (ohne Einschränkung q ≥ 1− q).

T (n) ≤ T (q · n) + c · n

= c · n+ q · c · n+ T (q2 · n) = ... = c · nlogq(n)−1∑

qi + T (1)

≤ c · n∞∑i=0

qi︸︷︷︸geom. Reihe

= c · n · 1

1− q= O(n)

Wie bekommen wir das hin?Der Zufall hilft uns (Tony Hoare, 1961). Wähle in jedem Schritt einenzufälligen Pivot.

schlecht schlechtgute Pivots

Wahrscheinlichkeit für guten Pivot nach einem Versuch: 12 =: ρ.

Wahrscheinlichkeit für guten Pivot nach k Versuchen: (1− ρ)k−1 · ρ.

Erwartungswert der geometrischen Verteilung: 1/ρ = 2237

Algorithmus Quickselect (A[l..r], i)Input : Array A der Lange n. Indizes 1 ≤ l ≤ i ≤ r ≤ n, so dass fur alle

x ∈ A[l..r] gilt, dass |{j|A[j] ≤ x}| ≥ l und |{j|A[j] ≤ x}| ≤ r.Output : Partitioniertes Array A, so dass |{j|A[j] ≤ A[i]}| = iif l=r then return;repeat

wahle zufalligen Pivot x ∈ A[l..r]p← lfor j = l to r do

if A[j] ≤ x then p← p+ 1

until l+r4≤ p ≤ 3(l+r)

4m← Partition(A[l..r], x)if i < m then

quickselect(A[l..m], i)else

quickselect(A[m..r], i)238

9. Rekursion - lec.inf.ethz.ch · Die Turme¨ von Hanoi - Rekursiver Losungsansatz¨ Links Mitte...

Documents

Transcript of 9. Rekursion - lec.inf.ethz.ch · Die Turme¨ von Hanoi - Rekursiver Losungsansatz¨ Links Mitte...

)/-Iv - dsv.rub.de · Bild 2. Signalfliii3graplieii rekursiver Filter a) direkte Form b) Kaskadenform mit L bzw. L - 1 Tcilfilterblöcken vom Grad 2 und 0 bzw. ciri Block von1 Grad

7. Beispiele primitiv rekursiver Funktionen · wiederum primitiv (partiell) rekursiv. Wir wollen nun zeigen, dass F(PRIM) und F(REK) allgemeiner gegen beliebige explizite Deﬁnitionen

SIEM - files.messe.defiles.messe.de/abstracts/63684_di_15_00_hock.pdf · 2 SIEM –Wenn Sie wüssten, was Ihre Systeme wissen… SIEM –was ist das? Security Information Event Monitoring

Keine Angst vorm „blauen Blut“: Diese Umgangsformen … · A 15/2 Adelige Umgangsformen heute • Ausgabe 4/2012 Adel und Adelstitel sind längst abgeschafft: Stimmt das? Wüssten

Informatik II Ubung 1 - lec.inf.ethz.ch · Ablauf Mo Di Mi Do Fr Sa So Mo Di Mi Do Fr Sa So Ausgabe Vorbesprechung Abgabe Nachbesprechung V Ü V Ü Übungsblattausgabe zur Vorlesung

Dinge, die wir ohne das Kino nie wüssten Ohne Kino wüssten wir nicht, dass … weiter mit Klick.

6. C++ vertieft (I) - lec.inf.ethz.ch · 6. C++ vertieft (I) Kurzwiederholung: Vektoren, Zeiger und Iteratoren Bereichsbasiertes for, Schlüsselwort auto, eine Klasse für Vektoren,

Woher wüssten wir, wie wir leben sollen, wenn wir nicht an etwas glaubten, das größer ist als wir? Wer würde uns lehren zu leben?

Sehr geehrte Damen und Herren, - Security-Finder Schweiz · Damit eine digitale Souveränität entstehen kann, müssen ... wüssten auch gerne, welche Daten über sie bei der öffentlichen

Lichtpunkte - HOME - Philosophicum · Philosophie, auch wenn wir vielleicht kaum einen rus- sischen Philosophen beim Namen zu nennen wüssten. Darüber hinaus verbindet sich mit dem

Sonderarbeitsblatt im Monat November 2016: …...Schule dies nicht zu, oder die Lehrkräfte wüssten nicht, wie sich ihre Ideen umsetzen lassen. Das Bundes-ministerium für Bildung

Parallele Programmierung - Basispr ufung - Seite 2 …lec.inf.ethz.ch/DA/2018/downloads/exams/bp_2015_w/bp...Parallele Programmierung - Basispr ufung - Seite 2 von 21 Montag, 1.2.2016

Wenn wir nur wüssten was wir Wissen - Start - OTMR€¦ · Besonderheiten: Naturschutzgebiet gegenüber for free: gutes Internet (WIFI, PC Ecke) Zimmer: sehr komfortable Betten (Groß,

Dez 2007Eibensteiner1 in der Übungsfirma Wenn wir zuerst wüssten, wo wir stehen und wohin wir streben, könnten wir besser beurteilen, was wir tun und wie.

Case Studies: Netzberechnung (Hardy-Cross Verfahren ...lec.inf.ethz.ch/baug/informatik2/2015/slides/BAUG_Informatik2_2015_lec08.pdf · Hardy Cross Verfahren Wiederhole 2 & 3 für

Wer wir waren! - stadtbibliothek-bielefeld.de · Wer wären wir, wenn wir wüssten, wer wir sind? Heike Ullmann Man begegnet ihnen überall, auf dem Weg zur Pommesbude, zum Supermarkt

Indonesien: Tabakindustrie setzt auf Kinder A · wati, seien die Hauptadressaten der Kampagnen der grossen Konzerne. Hinzu kommt, dass die Eltern oft nicht wüssten, das Rauchen schädlich

WENN DAS DIE LESER WÜSSTEN - Amadeus Verlag...Etwa 2.800 bislang geheime Dokumente zum Mord an John F. Kennedy wurden von Präsi-dent Donald Trump zur Veröffentlichung freigegeben.

Vor und Nachname (Druckbuchstaben)lec.inf.ethz.ch/DA/2019/downloads/exams/bp_2015_s/bp-solution.pdf · Parallele Programmierung - Basispr ufung - Seite 3 von 28 Montag, 10.08.2015

HAUPTPROGRAMM - koki-es.de · Verlängerung der open-air-saison zu goutieren wüssten! Ihr Kinoteam wünscht Ihnen einen wunder-schönen Sommer und freut sich auf Sie! 03 Made in