Paradigmen der Programmierung

Transkript

1 SS 11 Prüfungsklausur Aufgabe 5 (6+9 = 15 Punkte) a) Bestimmen Sie jeweils den Typ der folgenden Haskell-Ausdrücke: ( 1, 2 :"3", 4 < 5) :: (Char, String, Bool) [(last, tail), (head, take 5)] :: [ ([a] -> a, [b] -> [b]) ] [map (const True), map not] :: [ [Bool] -> [Bool] ] b) Gegeben seien die folgenden Funktionsdefinitionen. Bestimmen Sie jeweils den allgemeinsten Typ der Funktionen. Denken Sie auch an eventuelle Klasseneinschränkungen. Hinweis: Auftretende Zahlenkonstanten können Sie als Int interpretieren. f :: Ord a => Int -> [a] -> a -> Bool f x y z = head (drop x y) <= z elemindex :: Eq a => a -> [a] -> Maybe Int elemindex x xs = case [i (y,i) <- zip xs [0..], y == x] of [] -> Nothing (i:_) -> Just i g :: (Ord a, Num a) => [a] -> a -> [a] -> [a] g x y z = if sum x < y then x ++ z else tail x either :: (a -> c) -> (b -> c) -> Either a b -> c either f _ (Left x) = f x either _ g (Right y) = g y 5

2 SS 11 Prüfungsklausur Aufgabe 6 (9+11 = 20 Punkte) a) Definieren Sie eine Funktion zipwith :: (a -> b -> c) -> [a] -> [b] -> [c], welche als eine Verallgemeinerung der Funktion zip zwei Listen mittels einer übergebenen Funktion zu einer zusammenfügt. Die Ergebnisliste soll wie bei zip die Länge der kürzeren Argumentliste besitzen. zipwith (+) [1,2,3] [4,5,6,7,8] = [5,7,9] zip = zipwith (,) Geben Sie für diese Funktion drei verschiedene Implementierungen an: i) mittels expliziter Rekursion und ii) durch eine Listenkomprehension und Verwendung von zip und iii) durch eine geeignete Anwendung von map und zip Hinweis: Für diese Aufgabe können die Definitionen des Haskell Prelude-Moduls benutzt werden. Wenn Sie darüber hinaus Hilfsfunktionen verwenden, so müssen Sie diese auch definieren. i) zipwith f (x:xs) (y:ys) = f x y : zipwith f xs ys zipwith _ = [] -- auch korrekt: zipwith f [] _ = [] zipwith f _ [] = [] zipwith f (x:xs) (y:ys) = f x y : zipwith f xs ys ii) zipwith f xs ys = [f x y (x,y) <- zip xs ys] iii) zipwith f xs ys = map (\(x,y) -> f x y) (zip xs ys) 6

3 SS 11 Prüfungsklausur b) Die Prüfziffer bei einer ISBN-10 Nummer berechnet sich, indem die vorangehenden 9 Ziffern, gewichtet mit ihrer jeweiligen Position (beginnend bei 1), aufaddiert werden und der Rest der ganzzahligen Division durch 11 genommen wird (ein Rest von 10 wird üblicherweise als Ziffer X geschrieben, dies muss hier aber nicht beachtet werden): ( 9 ) z 10 = i z i i=1 mod 11 Definieren Sie eine Funktion isbn10 :: [Int] -> Int, welche eine Liste von neun Ziffern bekommt und daraus die ISBN-10 Prüfziffer berechnet. Geben Sie für diese Funktion zwei unterschiedliche Implementierungen an: i) Unter Verwendung einer rekursiven Hilfsfunktion über die Liste mit einem inkrementellen (also hochzählendem) Parameter und ii) mittels geschickter Funktionskomposition und der in a) definierten Funktion zipwith. Hinweis: Für diese Aufgabe können die Definitionen des Haskell Prelude-Moduls benutzt werden. Wenn Sie darüber hinaus Hilfsfunktionen verwenden, so müssen Sie diese auch definieren. i) isbn10 :: [Int] -> Int isbn10 xs = makesum 1 xs mod 11 where makesum _ [] = 0 makesum i (x:xs) = i*x + makesum (i+1) xs ii) isbn10 = ( mod 11). sum. zipwith (*) [1..] -- [1,2,3,4,5,6,7,8,9] 7

4 SS 11 Prüfungsklausur Aufgabe 7 ( = 19 Punkte) Gegeben sei folgender Datentyp zur Repräsentation von booleschen Ausdrücken: data BoolExpr = Value Bool And BoolExpr BoolExpr Not BoolExpr Der Ausdruck ( False True) True wird z.b. dargestellt als: And (And (Not (Value False)) (Value True)) (Value True) a) Schreiben Sie eine rekursive Funktion eval :: BoolExpr -> Bool, die einen booleschen Ausdruck auswertet. eval :: BoolExpr -> Bool eval (Value b) = b eval (And e1 e2) = (eval e1) && (eval e2) eval (Not e) = not (eval e) b) Definieren Sie eine Funktion foldboolexpr zur Faltung boolescher Ausdrücke gemäß der in der Vorlesung dargestellten Regeln zur Faltung von allgemeinen Datentypen. Geben Sie auch den Typ Ihrer Funktion an. foldboolexpr :: (Bool -> a) -> (a -> a -> a) -> (a -> a) -> BoolExpr -> a foldboolexpr val_f and_f not_f expr = f expr where f (Value b) = val_f b f (And e1 e2) = and_f (f e1) (f e2) f (Not e) = not_f (f e) c) Definieren Sie eval als Instanz von foldboolexpr. eval = foldboolexpr id (&&) not 8

5 SS 11 Prüfungsklausur Aufgabe 8 (6 Punkte) Ein Gray-Code ist eine Sequenz von binären Codewörtern mit der Eigenschaft, dass sich benachbarte Codewörter lediglich um ein einziges Bit unterscheiden. Definieren Sie eine Funktion gray :: Int -> [String], die für n 1 die n-bit Gray-Code Sequenz zurückliefert. gray 1 = ["0","1"] gray 2 = ["00","01","11","10"] gray 3 = ["000","001","011","010","110","111","101","100"] Überlegen Sie sich hierzu, wie der jeweilige n-bit Code aus dem (n 1)-Bit Code erzeugt werden kann. Hinweis: Für diese Aufgabe können die Definitionen des Haskell Prelude-Moduls benutzt werden. Wenn Sie darüber hinaus Hilfsfunktionen verwenden, so müssen Sie diese auch definieren. gray :: Int -> [String] gray 0 = [""] gray n = let xs = gray (n-1) in map ( 0 :) xs ++ map ( 1 :) (reverse xs) oder mit Listenkomprehension: gray :: Int -> [String] gray 0 = [""] gray n = [ 0 : x x <- prev ] ++ [ 1 : x x <- reverse prev ] where prev = gray (n-1) Auch korrekt: ohne 0-Bit Codewort gray 1 = ["0", "1"] gray n =... 9

6 SS 11 Prüfungsklausur Aufgabe 1 (6+9 = 15 Punkte) Haskell: Typisierung a) Bestimmen Sie jeweils den Typ der folgenden Haskell-Ausdrücke: map putchar [ a.. z ] :: [IO ()] (const 1, map (const "2")) :: (a -> Char, [b] -> [String]) [Left "Error", Right True] :: [Either String Bool] b) Gegeben seien die folgenden Funktionsdefinitionen. Bestimmen Sie jeweils den allgemeinsten Typ der Funktionen. Denken Sie auch an eventuelle Klasseneinschränkungen. f :: [[a]] -> [[a]] -> [a] f x y = concat (x ++ y) g :: (Ord a, Num b) => a -> a -> [b] -> [b] -> b g w x y z = if w < x then product y else sum z nub :: Eq a => [a] -> [a] nub = foldr (\x xs -> if x elem xs then xs else x:xs) [] err :: Show a => (Either a b) -> IO (Maybe b) err (Left msg) = do putstrln (show msg) return Nothing err (Right val) = do putstrln "Success!" return (Just val) 0

7 SS 11 Prüfungsklausur Aufgabe 2 (5+6+4 = 15 Punkte) Haskell: Listen und IO Für die folgenden Aufgaben dürfen Sie alle auf dem Übersichtsblatt angegebenen vordefinierten Funktionen verwenden. Alle anderen verwendeten Funktionen müssen explizit definiert werden. a) Schreiben Sie eine Funktion getnth :: [a] -> Int -> Maybe a, welche als ersten Parameter eine Liste l und als zweiten Parameter eine ganze Zahl n erhält. Diese Funktion liefert das n-te Element (bei 0 angefangen zu zählen) der übergebenen Liste. Kann dieser Wert nicht ermittelt werden (übergebener Index zu groß oder zu klein), soll Nothing zurückgeliefert werden. Prelude> getnth "Alexander" 5 Just n getnth [] _ = Nothing getnth _ n n < 0 = Nothing getnth (x:xs) 0 = Just x getnth (x:xs) n = getnth xs (n-1) b) Schreiben Sie eine Funktion getandremoventh :: [a] -> Int -> (Maybe a,[a]) welche ähnlich zu der Funktion getnth funktioniert, aber zusätzlich eine neue Liste zurückliefert, in der das n-te Element (bei 0 angefangen zu zählen) entfernt wurde. Sie dürfen dazu auch die Funktion getnth benutzen. Bei einem fehlerhaften Index (zu groß oder zu klein) soll Nothing und die ursprüngliche Liste zurückgeliefert werden. Prelude> getandremoventh "Alexander" 5 (Just n,"alexader") getandremoventh l n = let elem = getnth l n in case elem of Nothing -> (Nothing, l) Just x -> (elem, (take n l) ++ (drop (n+1) l)) 1

8 SS 11 Prüfungsklausur Aufgabe 3 ( = 30 Punkte) Haskell: Bäume und Faltung Eine Schlauchleitung bei der Feuerwehr besteht (stark vereinfacht) aus Schläuchen, Verteilern, und Strahlrohren. Die Schläuche und Strahlrohre haben zwei verschiedene Größen, welche mit B und C bezeichnet werden. Ein Verteiler hat einen B-Eingang, links und rechts C-Abgänge und in der Mitte einen B-Abgang. Von den Schlauchgrößen abgesehen, können Schläuche und Verteiler beliebig kombiniert werden. Ein Strahlrohr kann geöffnet (true) oder geschlossen (false) sein. An einem Verteiler sind immer alle Abgänge offen. Diese Zusammenhänge können zum Beispiel mit folgenden Datentypen beschrieben werden: data Groesse = B C deriving Eq data Leitung = Rohr Groesse Bool Schlauch Groesse Leitung Verteiler Leitung Leitung Leitung Die Konfiguration der im Bild skizzierten Schlauchleitung wird dann durch folgenden Ausdruck dargestellt: bsp = Schlauch B (Verteiler (Schlauch C (Schlauch C (Rohr C True))) (Schlauch B (Rohr B True)) (Rohr C False)) Mit diesen Datentypen ist es möglich, falsche Schlauch-/Anschlussgrößen zusammenzusetzen. Zum Beispiel macht Schlauch B (Schlauch C (Schlauch B)) in der Realität keinen Sinn. Es kann aber für alle folgenden Aufgaben davon ausgegangen werden, dass die jeweils übergebene Schlauchleitung korrekt zusammengesetzt ist. 3

9 SS 11 Prüfungsklausur a) Schreiben Sie eine rekursive Funktion gesamtlaenge :: Leitung -> Int, die die Gesamtlänge der eingesetzten Schläuche bestimmt. C-Schläuche haben eine normierte Länge von 15m, B-Schläuche eine Länge von 20m. Die Länge von Strahlrohren und Verteilern wird bei der Längenbestimmung nicht berücksichtigt. Prelude> gesamtlaenge bsp 70 gesamtlaenge (Schlauch x l) x == B = gesamtlaenge l + 20 x == C = gesamtlaenge l + 15 gesamtlaenge (Verteiler l1 l2 l3) = gesamtlaenge l1 + gesamtlaenge l2 + gesamtlaenge l3 gesamtlaenge _ = 0 b) Definieren Sie eine Funktion foldleitung zur Faltung des obigen Datentyps gemäß der in der Vorlesung dargestellten Regeln zur Faltung von allgemeinen Datentypen. Geben Sie auch den Typ Ihrer Funktion an. foldleitung :: (Groesse -> Bool -> a) -> (Groesse -> a -> a) -> (a -> a -> a -> a) -> Leitung -> a foldleitung rf sf vf l = f l where f (Rohr g b) = rf g b f (Schlauch g l) = sf g (f l) f (Verteiler l1 l2 l3) = vf (f l1) (f l2) (f l3) 4

10 SS 11 Prüfungsklausur c) Definieren Sie eine Funktion wassermenge :: Leitung -> Int als Instanz von foldleitung, welche die aktuell abgegebene Wassermenge einer Schlauchleitung bei einem festgelegten Druck angibt. Folgende Faustwerte werden dafür eingesetzt: C-Strahlrohre geben 100 l/min Wasser ab, B-Strahlrohre 400 l/min. Verteiler und Schläuche werden nicht berücksichtigt (obwohl sie in der Realität natürlich einen Einfluss haben). Bei der Berechnung soll allerdings schon berücksichtigt werden, ob das entsprechende Strahlrohr geöffnet oder geschlossen ist! Prelude> wassermenge bsp 500 wassermenge :: Leitung -> Int wassermenge = foldleitung (\g b -> if b then (if g==c then 100 else 400) else 0) (\g l -> l) (\l1 l2 l3 -> l1 + l2 + l3) d) Wie müssten die Datentypdefinitionen verändert werden, damit nur noch korrekte Schlauchleitungen instanziiert werden können? Es soll also nicht mehr möglich sein, dass zum Beispiel nach einem B-Schlauch eine Leitungskomponente (Schlauch oder Rohr) mit C-Größe angegeben werden kann. Geben Sie Vorschläge für die Datentypdefinitionen an! data BLeitung = BRohr Bool BSchlauch BLeitung Verteiler CLeitung BLeitung CLeitung data CLeitung = CRohr Bool CSchlauch CLeitung 5