Algorithmen und Programmierung WS 16/17 ¨Ubungsblatt 7 input N

TU Ilmenau, Fakultät IA
FG Telematik/Rechnernetze
Prof. Dr.-Ing. G. Schäfer
http://www.tu-ilmenau.de/telematik/aup
Algorithmen und Programmierung WS 16/17
Übungsblatt 7
Die Lösungen der Aufgaben sind am 12.12.16 in der Vorlesung abzugeben.
Aufgabe 1 (Korrektheit imperativer Algorithmen)
6 Punkte
Gegeben sei der folgende Algorithmus GAUSS. Zeigen Sie, dass
{N ≥ 0} GAUSS {S = N * (N + 1) / 2}
gilt.
GAUSS:
var N,C,S : int;
input N;
C := 0;
S := 0;
while C 6= N do
C := C + 1;
S := S + C;
od
output S.
Aufgabe 2 (Fallstricke bei Induktionsbeweisen)
3 Punkte
Folgender Induktionsbeweis scheint zu zeigen, dass 42 · n = 0 für alle n ∈ N0 gilt.
Beweis. (Per Induktion über n)
IA: n = 0 → 42 · 0 = 0
IS: < n → n:
Es seien x < n und y < n zwei Zahlen aus N0 mit x + y = n.
Dann folgt mit Hilfe der IV (für x und y):
42 · n = 42 · (x + y) = 42 · x + 42 · y = 0 + 0 = 0
Begründen Sie, warum dieser Beweis falsch ist.
Aufgabe 3 (Korrektheit applikativer Algorithmen)
3 Punkte
Gegeben sei die aus der Vorlesung bekannte Fibonacci-Folge:
F0 = F1 = 1, Fn = Fn−1 + Fn−2 für n ≥ 2
Beweisen Sie mittels vollständiger Induktion, dass der folgende applikative Algorithmus
die Fibonacci-Zahlen korrekt berechnet, d. h. dass fib(n) = Fn für alle n ≥ 0 gilt.
fib(n) =
if (x = 0) v (x = 1) then 1
else fib(n-2) + fib(n-1) fi
Bitte wenden!
2
Algorithmen und Programmierung WS 16/17
Aufgabe 4 (Vollständige Induktion)
Übungsblatt 7
3 + 3 + 4 Punkte
Beweisen Sie per vollständiger Induktion die folgenden Behauptungen.
(a)
n−1
P
i=0
2i = 2n − 1, für alle n ∈
N, n ≥ 1
(b) n3 + 2n ist durch 3 teilbar (ohne Rest), für alle n ∈
N, n ≥ 1
(c) Für die Fibonacci-Zahlen (siehe auch Aufgabe 3) gilt:
Fn+42 = Fn−2 · F42 + Fn−1 · F43 für alle n ≥ 2
Aufgabe 5 (Aufwandsschätzung in imperativen Programmen)
1 + 6 + 1 Punkte
Gegeben seien zwei Felder a und b aus ganzen Zahlen, welche bereits aufsteigend sortiert sind. Ferner wird angenommen, dass insgesamt keine Zahl aus a und b doppelt
vorkommt. Gesucht ist ein Algorithmus, welcher diese beiden Felder zu einem einzigen
sortierten Feld zusammenfügt.
Die folgende Java-Methode ist eine Möglichkeit, dieses Problem zu lösen:
public s t a t i c int [ ] dumbsort ( int [ ] a , int [ ] b ) {
int x , s = a . l e n g t h , l a s t=I n t e g e r . MIN VALUE ;
int [ ] c = new int [ a . l e n g t h + b . l e n g t h ] ;
for ( int i =0; i <c . l e n g t h ; i ++) {
int min=I n t e g e r .MAX VALUE;
f o r ( int j =0; j <c . l e n g t h ; j ++) {
i f ( j <s ) x=a [ j ] ; e l s e x=b [ j −s ] ;
i f ( ( x < min ) && ( l a s t < x ) ) min = x ;
}
c [ i ]=min ;
l a s t=min ;
}
return c ;
}
(a) Schätzen Sie den von der Methode dumbsort verursachten Aufwand an Rechenoperationen ab. Verwenden Sie dazu asymptotische Notation und gehen Sie davon
aus, dass die Felder a und b jeweils die Länge la bzw. lb haben.
(b) Schreiben Sie eine alternative Java-Methode, welche die Aufgabe mit einem Aufwand von O(la + lb ) löst.
(c) Begründen Sie, warum keine Lösung mit asymptotisch geringerem Aufwand existieren kann.