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

From VoWi
Jump to navigation Jump to search
m (→‎Aufgabe 2 (15% + 25%): entferne unnötige Klammern)
Line 20: Line 20:
 
t5 = [(i,sum [i..5]) | i<-m7] -- ??
 
t5 = [(i,sum [i..5]) | i<-m7] -- ??
  
t6 = ??
+
t6 = [[a]++[b]|a<-"ab", b<-((take 3.drop (m7!!6))['a'..'z'])]
  
 
p (x:xs) = p xs + x + p xs -- vllt Namen von Variablen waren unterschiedlich aber Struktur ist gleich
 
p (x:xs) = p xs + x + p xs -- vllt Namen von Variablen waren unterschiedlich aber Struktur ist gleich

Revision as of 20:38, 16 January 2020

Aufgabe 1 (50%)

Geben Sie Wert und allgemeinsten Typ für t1 bis t7 an!

-- 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 = [(i,sum [i..5]) | i<-m7] -- ??

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

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 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 a@(x:_) = (x, length (takeWhile (== x) a)) : rle (dropWhile (== x) a)
rle [] = []

Aufgabe 3 (5% + 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. (Geben Sie auch allgemeinste Typdeklaration!) 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]]