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

Aus VoWi
Zur Navigation springen Zur Suche springen

Aufgabe 1[Bearbeiten | Quelltext bearbeiten]

Foto der kompletten Test Angabe 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[Bearbeiten | Quelltext bearbeiten]

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

Lösung[Bearbeiten | Quelltext bearbeiten]

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

Aufgabe 3[Bearbeiten | Quelltext bearbeiten]

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

Lösung[Bearbeiten | Quelltext bearbeiten]

( (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[Bearbeiten | Quelltext bearbeiten]

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[Bearbeiten | Quelltext bearbeiten]

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[Bearbeiten | Quelltext bearbeiten]

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[Bearbeiten | Quelltext bearbeiten]

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[Bearbeiten | Quelltext bearbeiten]

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[Bearbeiten | Quelltext bearbeiten]

_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[Bearbeiten | Quelltext bearbeiten]

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[Bearbeiten | Quelltext bearbeiten]

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[Bearbeiten | Quelltext bearbeiten]

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