TU Wien:Funktionale Programmierung VU (Knoop)/Prüfung 2012-01-19

Aufgabe 1

mnr = [0,1,2,3,4,5,6]  :: [Int]
name = "Max Mustermann" :: String
kzn = "e53X" :: String


t1 = ( "p1",[head mnr],[(head.tail) mnr],((take 2 ). words . (\_ -> name)) 9);
{- t1 == ("p1", [0], [1], ["Max","Mustermann"]) -}

t2 = (\x y z a -> y(z(z(a))));
{- t2 ::  a -> (b -> c) -> (b -> b) -> b -> c -}

t3 = t2 product reverse (take 4) mnr;
{- t3 == [3,2,1,0] -}

t4 = ( [[i*2]|i<-mnr], [i|i<-mnr,i>3] )
{- t4 == ( [[0],[2],[4],[6],[8],[10],[12]], [4,5,6] ) -}

t5 = [[j | j <- [1..i]] | i <- mnr, i < 9]
{- t5 == [[],[1],[1,2],[1,2,3],[1,2,3,4],[1,2,3,4,5],[1,2,3,4,5,6]] -}

ml n l = drop 5 l ++ take n l
t6 = ( ml 2 mnr, [(i,j)|i<- ml 2 mnr, j <- ml 2 mnr, j<i] )
{- t6 == ( [5,6,0,1], [(5,0),(5,1),(6,5),(6,0),(6,1),(1,0)] ) -}

p (a:b:l) xs ys = p l (a:b:xs) (b:ys)
p _ xs ys = (sum xs, product ys)
t7 = (p [mnr!!5, mnr!!6] [] [], p mnr [] []
{- t7 == ((11,6),(15,15)) -}

--(da mnr!!5 == 4 und mnr!!6 == 5 ist {- t7 ==([9], (5))-} //meine meinung nach es ist falsch; sollte falsch sein,
--da index einer liste bei 0 beginnt, [0,1,2,3]!!0 == 0 ist True..
--WICHTIG: wertet man Beispiel t7 in ghci aus, kommt als Resultat t7 == ((11,6),(15,15)). Das Beispiel ist also korrekt gelöst.

Aufgabe 2

Ein binärer Baum dessen Knoten ein polymorphes Element enthalten, und Leerknoten zulässt.

Lösung

data BTree a = Nil
             | Node a (BTree a) (BTree a)

Aufgabe 3

Einen Typ (BTree Integer, BTree String) der die werte 1,2 und "ab" enthält Zeichen und in Haskell Notation ausschreiben.

Lösung

( (Node 1 (Node 2 Nil Nil) Nil), (Node "ab" Nil Nil) )

Zeichnung (von Merenwen):

             Node 1                           Node "ab"
            /      \                         /        \
       Node 2      Nil                    Nil         Nil
      /      \
     Nil      Nil

Aufgabe 4

Eine boolsche Funktion "kdif" mit einem Eingabeparameter BTree a, die True zurück liefert wenn das polymorphe Element der aktuellen Knotens in keinem der aktuellen Unterbäume vorkommt. (Im Prinzip wie hier nur auf Nullknoten angepasst). + (Extrapunkte glaub ich) eine Typklasse für kdif definieren.

Lösung von judas

kdif :: Eq a => BTree a -> Bool
kdif Nil = True
kdif (Node a Nil Nil) = True
--kdif (Node a bt1 Nil) = kdif (Node a Nil bt1) --nicht benoetigt
kdif (Node a Nil bt2@(Node a1 bt2a bt2b))
  | a == a1 = False
  | not (kdif (Node a bt2a bt2b)) = False
  | otherwise = kdif bt2
kdif (Node a bt1 bt2) =
  kdif (Node a Nil bt1) &&
  kdif (Node a Nil bt2)

Lösung von r0f1

kdif :: Eq a => BTree a -> Bool
kdif Nil = True
kdif (Node a r l) = not(elem a (flatten r ++ flatten l)) -- && (kdif r) && (kdif l) {- mit diesem Teil würde das Funktion die Bedingung auch für alle Unterknoten 
-- überprüfen, was laut Angabe nicht erwünscht ist. -}
	
flatten :: BTree a -> [a]
flatten Nil = []
flatten (Node a l r) = [a] ++ flatten l ++ flatten r

Lösung von Merenwen

kdif :: Eq a => BTree a -> Bool
kdif Nil = True
kdif (Node a l r) = kdif_help l a && kdif_help r a
                    && kdif l && kdif r {- Das hat noch gefehlt damit der Baum ganz durchgegangen wird,
                                           ansonsten würde "kdif (Node 1 (Node 2 Nil (Node 2 Nil Nil)) Nil)" True ergeben, was aber false ist. -}

kdif_help:: Eq a => BTree a -> a -> Bool
kdif_help Nil _ = True
kdif_help (Node x l r) y
	|x == y = False
	|otherwise = kdif_help l y && kdif_help r y

Lösung von Stampi

class KDifferenz a where
	kdif :: a -> Bool

kdifRec :: Eq a => (BTree a) -> a -> Bool
kdifRec Nil val = True
kdifRec (Node v l r) val
	| (v == val) = False
	| otherwise = kdifRec l val && kdifRec r val

kdifTree :: Eq a => (BTree a) -> Bool
kdifTree Nil = True
kdifTree (Node v l r) = kdifRec l v && kdifRec r v
	
instance Eq a => KDifferenz (BTree a) where
	kdif = kdifTree

Lösung von rhs

_kdif :: (Eq a) => (BTree a) -> Bool
_kdif Nil = True
_kdif x@(Node a t1 t2) =
	let t Nil = True;
		t (Node b tx ty) = a /= b && t tx && t ty;
	in t x;

class KDif a where
	kdif :: a -> Bool

instance Eq a => KDif (BTree a) where 
	kdif = _kdif;

Aufgabe 5

Eine Funktion "filtert" die als Parameter eine boolsche Funktion mit genau einem Eingabeparameter, und BTree a nimmt, welche alle polymorphen Elemente zurückliefert, für die die boolsche Funktion True liefert.

Lösung von thomas

tfilter :: (a -> Bool) -> BTree a -> [a]
tfilter f (BNode v l r)
  | (f v)     = v : rest -- if ( f(v) ) then ...
  | otherwise = rest
  where
    rest = tfilter f l ++ tfilter f r
tfilter _ _ = []

Lösung von r0f1

filtert :: (a -> Bool) -> BTree a -> [a]
filtert f t = filter f (flatten t)

Materialien

Neues Material hinzufügen

T

• TU Wien-Funktionale Programmierung VU (Knoop) - Test Aufgabe1.jpg (details)