TU Wien:Funktionale Programmierung VU (Knoop)/Prüfung 2020-01-16: Difference between revisions

From VoWi
Jump to navigation Jump to search
 
Line 51: Line 51:


count _ _ = 0
count _ _ = 0
</source>
Andere Lösung:
<source lang="haskell">
rle :: Eq a => [a] -> [(a, Int)]
rle [x] = [(x, 1)]
rle (x:xs)
    | x == y = (y, n + 1):ys
    | otherwise = (x, 1):ls
    where
        ls@((y, n):ys) = rle xs
</source>
</source>



Latest revision as of 22:56, 13 January 2021

Aufgabe 1 (50%)[edit]

Geben Sie Wert und allgemeinsten Typ für t1 bis t7 an! (Der Text enthält vorgeschlagene Lösungen als Kommentare die hier hier weiß gedruckt werden. Durch Auswählen des Texts oder über den Seitenquellcode könnt ihr diese Lösungen lesen/copy-pasten.)

-- Name und m7 ausfüllen
m7 = tail [_,_,_,_,_,_,_,_] :: [Integer] -- Matrikelnummer
name = "                  " :: String -- Name

t1 = ("p1", length m7, (show.drop 4)m7, (zip name.take 7)"No")
{- t1 :: ([Char], Int, [char], [(Char, Char)]) -}

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

t3 = t2 (take 5) (\x -> x++x) reverse m7 
{- t3 :: [Integer] -}

t4 = (drop 4 [[i-2] | i<-m7], take 4 [i | i<-m7, i>4]) 
{- t4 :: ([[Integer]], [Integer]) -}

t5 = [(i,sum [i..5]) | i<-m7]
{- t5 :: [(Integer, Integer)] -}

t6 = [(++) [a] [b]|a<-"ab", b<-((take 3.drop (m7!!6))['a'..'z'])]
{- t6 :: [[Char]] -}

p (x:xs) = p xs + x + p xs -- Variablennamen waren vlt. unterschiedlich, Struktur war so
p _ = 0
{- zusammengefasst: p <any finite list> = 0) -}

t7 = (p [(m7!!6)], p [(m7!!5), (m7!!6)], p m7)
{- t7 :: (Integer, Integer, Integer) -}

Aufgabe 2 (15% + 25%)[edit]

Eine Funktion heißt rle schreiben. rle nimmt eine Liste von Elementen und gibt eine Liste von Tupeln aus, wo der Tupel = (Element a, wie oft ist dieses Element a nacheinander aufgetreten). (Geben Sie auch allgemeinste Typdeklaration!)

Beispiel: rle "aabbaaac" = [('a',2), ('b', 2), ('a',3), ('c', 1)]. oder rle [1,1,1,2,3,3] = [(1,3) ,(2,1), (3,2)]

rle :: (Eq a) => [a] -> [(a,Int)]

rle (x:xs) = (x, 1 + (count x xs)) : rle ( drop ((count x xs)) xs)
rle _ = []

count :: (Eq a) => a -> [a] -> Int
count a (x:xs)
 | a == x = 1 + count a xs
 | otherwise = 0

count _ _ = 0

Andere Lösung:

rle :: Eq a => [a] -> [(a, Int)]
rle [x] = [(x, 1)]
rle (x:xs)
    | x == y = (y, n + 1):ys
    | otherwise = (x, 1):ls
    where 
        ls@((y, n):ys) = rle xs

Andere Lösung:

rle :: (Eq a) => [a] -> [(a,Int)]
rle a@(x:_) = (x, length (takeWhile (== x) a)) : rle (dropWhile (== x) a)
rle [] = []

Andere Lösung:

rle :: (Eq a) => [a] -> [(a,Integer)]
rle [] = []
rle (x:xs) = rle' x 1 xs

rle' :: (Eq a) => a -> Integer -> [a] -> [(a,Integer)]
rle' a n [] = [(a,n)]
rle' a n (x:xs)
  | a == x     = rle' a (n+1) xs
  | otherwise  = (a,n):(rle' x 1 xs)

Aufgabe 3 (5% + 5%)[edit]

Eine Funktion heißt unrle, die reverse von rle ist. Es nimmt die Ausgabetyp von rle und wandelt es wieder zu einer Liste um. (Geben Sie auch allgemeinste Typdeklaration!) Beispiel : unrle( rle s ) = s

unrle :: (Eq a) => [(a,Int)] -> [a] 
unrle (x:xs) = help x xs
unrle [] = []

help (a,b) (x:xs) = [a | i <- [1..b]] ++ help x xs
help (a,b) _ = [a | i <- [1..b]]

Andere Lösung:

unrle :: [(a,Int)] -> [a] 
unrle ((a,b):r) = [a | i <- [1..b]] ++ unrle r
unrle [] = []

Andere Lösung:

unrle :: [(a,Integer)] -> [a]
unrle [] = []
unrle ((a,n):xs)
  | n > 0     = a:unrle ((a,n-1):xs)
  | otherwise = unrle xs

Andere Lösung:

unrle :: [(a,Int)] -> [a]
unrle [] = []
unrle ((a,n):xs) = replicate n a ++ unrle xs