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

From VoWi
Jump to navigation Jump to search
(Die Seite wurde neu angelegt: „==Aufgabe 1 (50%)== Geben Sie Wert ''und'' allgemeinsten Typ für ''t1'' bis ''t7'' an! (Hier im VoWi kannst du die leeren Zeilen auswählen um die Lösungen z…“)
(No difference)

Revision as of 20:53, 16 January 2020

Aufgabe 1 (50%)

Geben Sie Wert und allgemeinsten Typ für t1 bis t7 an! (Hier im VoWi kannst du die leeren Zeilen auswählen um die Lösungen zu sehen.)

-- 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") --Nicht ganz sicher 


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

t3 = t2 ?? (\x -> x++x) reverse m7 -- t2 nutzt kein x,so es ist egal was beim ersten parameter steht

t4 = (drop 4 [[i-2] | i<-m7], take ? [i | i<-m7, i>4]) -- ich glaube es war take 3 aber nicht sicher.

t5 = take 4 [[i|j<-[i..5]] | i<-mnr]
{- t5 = [[1,1,1,1,1], [2,2,2,2], [3,3,3], [4,4]] :: [[Integer]] -}


t6 = ??


p (x:xs) = p xs + x + p xs -- vllt Namen von Variablen waren unterschiedlich aber Struktur ist gleich
p _ = 0

t7 = (p (drop m7!!6 m7), p (drop m7!!5 m7), p m7)

Aufgabe 2 (15% + 25%)

Eine Funktion heißt rle schreiben. rle nimmt eine Liste von Elementen und gibt eine Liste von Tupeln aus, wo der Tupel = (Element, Wie viel mal dasselbe Element nacheinander kommt). (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)]

Meine Lösung (geprüft mit Hugs):

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

Aufgabe 3 (5%)

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

Meine Lösung (geprüft mit Hugs): -- Man kann natürlich einfachere Lösung finden, aber wenn es richtig ist, ist es egal, wie man das Problem löst.

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

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