Lösung: InfA - Übungsblatt 07

Größe: px

Ab Seite anzeigen:

Download "Lösung: InfA - Übungsblatt 07"

Mathilde Glöckner
vor 6 Jahren
Abrufe

1 Lösung: InfA - Übungsblatt 07 Michele Ritschel & Marcel Schilling 23. Dezember 2008 Verwendete Abkürzungen: Beweis, vollständige Induktion, IA: Induktionsanfang/Induktionsanker, IS: Induktionsschritt/Induktionssprung, IV: Induktionsvorraussetzung ( =IB: Induktionsbehauptung) 1 Vollständige Induktion I Zeigen Sie mit vollständiger Induktion, dass für alle natürlichen Zahlen n gilt: i t e r n id = id Dabei ist die Iterationsfunktion definiert durch i t e r : : Int > ( a >a ) > ( a >a ) i t e r n f n > 0 = f. i t e r (n 1) f i t e r. 1 o t h e r w i s e = id i t e r. 2 und id :: a >a ist die polymorphe Identitätsfunktion, durch id x = x gegeben. IA: n = 0 iter 0 id iter.2 = id IS: iter (n 1) id = id iter n id = id iter n id iter.1 = id. iter (n 1) id f.g = f(g) = id ( iter (n 1) id) IV = id id id = id 1

2 2 Vollständige Induktion II Beweisen Sie mittels Indution für alle endlichen Listen (von Listen) xs und alle Funktionen f, dass gilt concat (map (map f) xs) = map f (concat xs) Zur Erinnerung: concat : : [ [ a ] ] > [ a ] concat [ ] = [ ] concat. 1 concat ( x : xs ) = x++concat xs concat. 2 map g [ ] = [ ] map. 1 map g ( x : xs)= g x : map g xs map. 2 Vorraussetzung: (++) : : [ a ] > [ a ] > [ a ] (++) l s 1 [ ] = l s 1 (++.1) (++) [ ] l s 2 = l s 2 (++.2) (++) ( x1 : xs1 ) l s 2 = x1 : ( xs1++l s 2 ) (++.3) Lemma: map f ys ++ map f zs = map f (ys ++ zs) VI über Länge ys: IA: Länge ys = 0 ( ys = []) map f [] ++ map f zs map.1 = []++map f zs ++.2 = map f zs ++.2 = map f ([]++zs) IS: map f ys ++ map f zs = map f (ys++zs) map f (y:ys) ++ map f zs = map f ((y:ys)++zs) map f (y:ys) ++ map f zs map.2 = (f y : map f ys) ++ map f zs ++.3 = f y :(map f ys ++ map f zs) IV =f y :map f (ys++zs) map.2 = map f (y:(ys++zs)) ++.3 = map f ((y:ys)++zs) IA: Länge xs = 0 ( xs = []) concat (map (map f) []) map.1 = concat [] concat.1 = [] map f (concat []) concat.1 = map f [] map.1 = [] 2

3 concat (map (map f) []) = [] map f (concat []) = [] concat (map (map f) []) = map f (concat []) IS: concat (map (map f) xs) = map f (concat xs) concat (map (map f) (x:xs)) = map f (concat (x:xs)) concat (map (map f) (x:xs)) map.2 = concat (map f x : map (map f) xs) concat.2 = (map f x)++concat (map (map f) xs) IV =(map f x)++(map f (concat xs)) Lemma = (map f (x++(concat xs))) concat.2 = (map f ((concat x:xs))) 3 Vollständige Induktion III Beweisen Sie mittels vollständiger Induktion über die Listenlänge, dass für alle Listen xs gilt: length ( reverse xs) = length xs wobei reverse die Funktion ist, die eine Liste umdreht, definiert mittels: r e v e r s e [ ] = [ ] r e v e r s e. 1 r e v e r s e ( z : zs ) = r e v e r s e zs ++ [ z ] r e v e r s e. 2 Vorraussetzung: l e n g t h : : [ a ] > Int l e n g t h [ ] = 0 length. 1 l e n g t h ( y : ys ) = 1 + l e ngth ys length : : [ a ] > [ a ] > [ a ] ++ l s 1 [ ] = l s [ ] l s 2 = l s ( x1 : xs1 ) l s 2 = x1 : ( xs1++l s 2 ) ++.3 Lemma: length (ys++zs) = length ys + length zs VI über Länge ys: IA: Länge ys = 0 ( ys=[]) length ([]++zs) ++.2 = length zs a=0+a = 0 + length zs length.1 = length [] + length zs 3

4 IS: length (ys++zs) = length ys + length zs length ((y:ys)++zs) = length (y:ys) + length zs length ((y:ys)++zs) ++.3 = length (ys:( ys++zs) length.2 = 1 + length (ys++zs) IV =1 + (length ys + length zs) b+(c+d)=(b+c)+d = (1 + length ys) + length zs =length (y:ys) + length zs IA: Länge xs = 0 ( xs = []) length (reverse []) reverse.1 = length [] IS: length( reverse xs) = length xs length( reverse (x:xs)) = length (x:xs) length (reverse (x:xs)) reverse.2 = length ( reverse xs ++ [x]) Lemma = (length ( reverse xs)) + (length [x]) IV =(length xs) + (length [x]) a+b=b+a = (length [ x]) + (length xs) [x]=x:[] = (length (x :[])) + (length xs) length.2 = (1+ (length [])) + (length xs) length.1 = (1+0) + (length xs)) c+0=c = 1 + (length xs) length.2 = (length x:xs) 4 Linksfaltung Beschreiben und begründen Sie verbal, was folgende Linksfaltung tut. wastuich xs1 xs2 = f o l d l func xs1 xs2 func [ ] = [ ] func ( x : xs ) y x = = y = xs o t h e r w i s e = x : ( func xs y ) Die Funktion wastuich erhält zwei Listen über eine Typen, der Gleichheitsabfragen erlaubt. Aus der ersten Liste streicht sie alle Einträge so oft, wie sie auch in der zweiten Liste enthalten sind und gibt dann die erste Liste ohne diese 4

5 übereinstimmenden Einträge wieder zurück. Dies tut sie mit Hilfe einer Linksfaltung ( foldl ). foldl ruft die Funktion func, die das erste Vorkommen eines Werts in einer Liste entfernt, nach und nach mit allen Elementen der zweiten Liste auf. Bekommt func die leere Liste gibt sie auch die leere Liste zurück. Erhält foldl eine nichtleere Liste ruft diese func mit der ersten Liste auf und vergleicht diese Liste mit dem Kopf der zweiten Liste. Ist dieser Kopf in der ersten Liste enthalten, so streicht sie ihn und gibt den Rest der ersten Liste zurück. Im anderen Fall, also wenn der Kopf der zweiten Liste nicht in der ersten enthalten ist, gibt die Funktion die Liste ohne Veränderung zurück. Dieser Vorgang geht rekursiv weiter bis die zweite Liste die leere Liste ist, wobei jeweils das Ergebnis des vorherigen Durchlaufs als erstes Argument für func dient. Dies entspricht der rekursiven Definition einer Linksfaltung, bei der für eine nichtleere Liste (x:xs) (hier xs2) der Startwert (hier xs1) geändert wird: f o l d l f e ( x : xs ) = f o l d l f ( f e x ) xs 5

Ähnliche Dokumente

Funktionale Programmierung mit Haskell

Funktionale Programmierung mit Haskell Dr. Michael Savorić Hohenstaufen-Gymnasium (HSG) Kaiserslautern Version 20120622 Überblick Wichtige Eigenschaften Einführungsbeispiele Listenerzeugung und Beispiel