Teillösung zum 7.Aufgabenblatt zur Vorlesung Informatik A

Transkript

1 1 Teillösung zum 7.Aufgabenblatt zur Vorlesung Informatik A (Autor: Florian Brinkmeyer) 1 Pascalsches Dreieck Implementieren Sie die Rekursion zur Berechnung der Binomialkoezienten. Geben Sie die ersten 12 Zeilen des Pascalschen Dreieckes auf dem Bildschirm aus. Die einzelnen Zeilen sollten linksbündig sein, danach jeweils eine Leerzeile, zwischen den Einträgen einer Zeile jeweils ein ( Leerzeichen. n Zur Erinnerung: Der Binomialkoezient k) ist für nichtnegative ganze Zahlen n und k rekursiv deniert als: n 0 : ( ( n 0) = 1, 0 n < k : n k) = 0 n k : ( ) ( n k = n 1 ) ( k 1 + n 1 ) k Programmierlösung: lines_count :: Int lines_count = verknüpft Berechnungvariante A mit der Ausgabevariante A var1 = showpascala createpascala -- verknüpft Berechnungsvariante A mit der Ausgabevariante B var2 = showpascala createpascalb -- verknüft Berechnungsvariante B mit der Ausgabevariante B var3 = showpascalb -- erste Berechnungsvariante für das Pascalsche Dreieck (A): -- auf die Erfordernisse der Aufgabe zugeschnittene Definition -- des Binomialkoeffizienten

2 binom:: Int -> Int -> Int binom n k k<0 = 0 n==k = 1 otherwise = binom (n-1) k + binom (n-1) (k-1) -- erzeugt die n-te Zeile createlinea:: Int -> [Int] createlinea n = map (binom n) (take (n+1) [0,1..]) -- erzeugt die Werte des Gesamtdreiecks createpascala:: [[Int]] createpascala = map createlinea (take lines_count [0,1..]) -- effizientere Berechnungsvariante (B): -- Es wird die aktuelle Zeile unter Rückgriff auf die vorige berechnet. createlineb :: [Int] -> [Int] createlineb oldline = reverse (1:createLineBHelp oldline [1]) createlinebhelp :: [Int] -> [Int] -> [Int] createlinebhelp (x:y:xs) newline = createlinebhelp (y:xs) ((x+y):newline) createlinebhelp _ newline = newline -- erzeugt das Gesamtdreieck createpascalb :: [[Int]] createpascalb = [1]:[createLineB xs xs<-take (lines_count-1) createpascalb] -- wandelt die Einzelwerte des Dreiecks in Zeichenketten um pascalstring :: [[Int]] -> [[String]] pascalstring pascal = map (map show) pascal

3 -- linksbündige Ausgabe des Ergebnisses (A): -- Die einzelnen Einträge einer Zeile werden durch ein Leerzeichen getrennt -- und dann zu einem Gesamtstring verbunden. showlinea:: [String] -> String showlinea = concat.(map (++" ")) -- Nach der Erzeugung des Dreiecks in Zeichenform werden die einzelnen -- Ausgabezeilen generiert, mit zwei Zeilenumbrüchen ("\n") versehen, -- zu einem Gesamtstring verknüpft und das Ergebnis wird mit putstrln -- ausgegeben. showpascala :: [[Int]] -> IO() showpascala pascal = putstrln (concat [(showlinea xs)++"\n\n" xs<-pascalstring pascal]) -- zentrierte Ausgabevariante (B) -- Als Breite eines Ausgabeblocks wird die maximale Länge -- eines Eintrags verwendet. blockwidth :: Int blockwidth = maximum (map length (concat (pascalstring createpascalb))) -- Übergeben wird die Spalte, in der die Ausgabe der Zeile beginnen soll -- und für den rekursiven Aufruf auch die gegenwärtige Position. -- Der Abstand zwischen zwei Einträgen ist ebenfalls blockwidth. -- Jeder Eintrag wird innerhalb seines Ausgabeblocks zentriert. showlineb:: Int -> Int -> [String] -> String showlineb start pos (x:xs) = take offset [' ',' '..] ++ x ++ showlineb (start+2*blockwidth) (pos+offset+length x) xs where offset = start-pos+center center = (blockwidth-length x) `div` 2 showlineb [] = "\n"

4 -- Erzeugt der Reihe nach die Ausgabezeilen showpascalbhelp:: Int -> [[String]] -> String showpascalbhelp i (xs:xss) = showlineb start 0 xs ++ showpascalbhelp (i+1) xss where start = (lines_count-i)*blockwidth showpascalbhelp _ [] = [] showpascalb :: IO() showpascalb = putstrln (showpascalbhelp 1 (pascalstring createpascalb)) 2 Vollständige Induktion I a) 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: reverse [] = [] reverse (z:zs) = reverse zs ++ [z] --reverse.1 --reverse.2 length [] = 0 length (y:ys) = 1 + length ys --length.1 --length.2 Beweis Für den Beweis wird folgende Zusatzannahme verwendet: length (xs++ys) = length xs + length ys Diese lässt sich ebenfalls durch vollständige Induktion beweisen. Induktionsanfang (IA) (Länge xs = 0 => xs = []) length (reverse []) = length [] --reverse.1 Induktionsvoraussetzung (IV) length (reverse xs) = length xs

5 für alle xs der Länge n Induktionsbehauptung (IB) length (reverse (x:xs)) = length (x:xs) Induktionsschritt (IV => IB) length (reverse (x:xs)) --reverse.2 = length (reverse xs ++ [x]) --Zusatzannahme = length (reverse xs) + length [x] --Induktionsvoraussetzung = length xs + length [x] --Definition von [x] = length xs + length x:[] --length.2 = length xs length [] --length.1 und Termumformung = 1 + length xs --length.2 = length (x:xs) Es wurde also gezeigt, dass die Behauptung für xs = [] gilt. Ferner wurde gezeigt, dass, wenn sie für beliebige xs der Länge n gilt, daraus folgt, dass sie auch für beliebige xs der Länge n+1 gilt. Nach dem Prinzip der vollständigen Induktion ist damit die Behauptung bewiesen. Beweis der Zusatzannahme Es ist zu zeigen: length (xs++ys) = length xs + length ys Für den Nachweis muss noch der (++)-Operator definiert werden: [] ++ ys = ys --(++).1 (x:xs) ++ ys = x:(xs++ys) --(++).2 Vollständige Induktion über die Listenlänge von xs: Induktionsanfang (IA) length ([]++ys) --(++).1 = length ys = 0 + length ys --length.1 = length [] + length ys

6 6 Induktionsvoraussetzung (IV) length (xs++ys) = length xs + length ys für alle xs der Länge n Induktionsbehauptung (IB) length ((x:xs)++ys) = length (x:xs) + length ys Induktionsschritt (IV=>IB) length ((x:xs)++ys) --(++).2 = length x:(xs++ys) --length.2 = length (xs++ys) Induktionsvoraussetzung und Termumformung = length xs length ys --length.2 = length (x:xs) + length ys Vollständige Induktion I b) Beweisen Sie auÿerdem, dass für HaskellListen die folgende Gleichheit auf Funktionenebene gilt, wobei id die Identitätsfunktion ist und der (.)-Operator für Funktionskomposition steht. reverse. reverse = id Beweis reverse. reverse = id <=> (reverse. reverse) xs = xs für alle xs <=> reverse (reverse xs) = xs für alle xs Der Beweis erfolgt durch Induktion über die Listenlänge von xs. Es wird folgende Zusatzannahme verwendet: reverse (xs++ys) = reverse ys ++ reverse xs Diese beweist man ebenfalls durch Induktion. Induktionsanfang (IA) reverse (reverse []) --reverse.1 = reverse [] --reverse.1 = []

7 Induktionsvoraussetzung (IV) reverse (reverse xs) = xs für alle xs der Länge n Induktionsbehauptung (IB) reverse (reverse (x:xs)) = x:xs Induktionsschritt (IV=>IB) reverse (reverse (x:xs)) --reverse.2 = reverse (reverse xs ++ [x]) --Zusatzannahme = reverse [x] ++ reverse (reverse xs) --Induktionsvoraussetzung = reverse [x] ++ xs --Definition von [x] = reverse (x:[]) ++ xs --reverse.2 = reverse [] ++ [x] ++ xs --reverse.1, Definition von [x] = [] ++ x:[] ++ xs --(++).1, (++).2 = x:([]++xs) --(++).1 = x:xs Beweis der Zusatzannahme Es ist zu zeigen: reverse (xs++ys) = reverse ys ++ reverse xs Beweis durch Induktion über die Listenlänge von xs Hierbei wird folgende Zusatzannahme verwendet: xs ++ [] = xs Diese ist anders als [] ++ xs = xs nicht Teil unserer Definition von (++) und muss eigentlich ebenfalls durch Induktion bewiesen werden. Induktionsanfang (IA) reverse ([]++ys) --(++).1 = reverse ys --Zusatzannahme = reverse ys ++ [] --reverse.1 = reverse ys ++ reverse []

8 Induktionsvoraussetzung (IV) reverse (xs ++ ys) = reverse ys ++ reverse xs für alle xs der Länge n Induktionsbehauptung (IB) reverse ((x:xs) ++ ys) = reverse ys ++ reverse (x:xs) Induktionsschritt reverse ((x:xs) ++ ys) --(++).2 = reverse (x:(xs++ys)) --reverse.2 = reverse (xs++ys) ++ [x] --Induktionsvoraussetzung = reverse ys ++ reverse xs ++ [x] --reverse.2 = reverse ys ++ reverse (x:xs) Links- und Rechtsfaltung a) Beschreiben und begründen Sie verbal, was folgende Linksfaltung tut. wastuich xs1 xs2 = foldl func xs1 xs2 func [] _ = [] func (x:xs) y x==y = func xs y otherwise = x: (func xs y) Die Hilfsfunktion 'func' löscht alle Vorkommnisse des Elements, das sie als zweiten Parameter erhält, aus der Liste, die sie als ersten Parameter erhält und liefert die Restliste zurück. Dies wird durch eine Rekursion realisiert. Die Elemente der Liste werden der Reihe nach mit dem zweiten Parameter verglichen und nur im Falle einer Ungleichheit in die Ergebnisliste übernommen. Die Funktion 'wastuich' löscht auch bei mehrfachem Auftreten alle Elemente aus xs1, die ebenfalls in xs2 vorkommen. Hierbei wird auf eine Linksfaltung der Funktion 'func' über der Liste xs2 zurückgegrien. Die anfangs noch vollständige Liste xs1 fungiert hierbei als Startwert für die Faltungsoperation. Es werden sukzessive die Elemente von xs2 durchlaufen und jeweils alle Vorkommnisse des aktuellen Elements aus der jeweiligen Restliste von xs1 gelöscht.

9 Links- und Rechtsfaltung b) Was tut die Funktion mystery xs = foldr (++) [] (map sing xs), wobei sing x = [x] für alle x ist? Die Funktion 'sing' bildet aus dem Parameter x eine Liste, die x als einziges Element enthält. 'map sing xs' liefert demnach eine Liste, deren Elemente einelementige Listen sind, die aus den Elementen von xs gebildet wurden. Die abschlieÿende Faltungsoperation entspricht einer Konkatenation und damit einer erneuten Zusammenführung dieser einelementigen Listen, so dass man wieder xs erhält. 'mystery' realisiert demnach für Listen die Identitätsfunktion.