Aufgabe 2 - Goethe

Prof. Dr. Manfred Schmidt-Schauß
Künstliche Intelligenz/Softwaretechnologie
Fachbereich Informatik und Mathematik/ Institut für Informatik
Goethe-Universität Frankfurt am Main
Grundlagen der Programmierung 2
Sommersemester 2013
Aufgabenblatt Nr. 4
Abgabe: Mittwoch 15. Mai 2013 vor! der Vorlesung
Aufgabe 1 (20 Punkte)
Berechnen Sie die Menge der freien Variablen FV (si ) und der gebundenen Variablen GV (si ) für die
folgenden Ausdrücke s1 und s2 :
(jeweils 10 Punkte)
a) s1 := \x -> if y then \z -> (x \y -> y) else (\z -> w) x
b) s2 := let f x1 x2 = y1 (\x -> x2 ) in let y1 = f w (f y2 y2 ), y2 = y1 in f
Aufgabe 2 (30 Punkte)
Geben Sie jeweilse eine List Comprehension in Haskell an, welche die folgenden Listen erzeugt:
a) Die Liste aller Quadratzahlen n2 (n ∈ N), die durch 6, aber nicht durch 5 teilbar sind.(8 Punkte)
b) Die Liste aller Paare (x, y), mit x, y ∈ N, wobei
–
–
–
–
x ist das Produkt zweier natürlichen Zahlen (d.h. x = a · b, mit a, b ∈ N), und
x is echt größer als 5 aber echt kleiner als 500, und
y ist eine Quadratzahl (d.h. y = c2 für c ∈ N) nicht größer als 1000, und
x ist ein Teiler von y.
(12 Punkte)
c) Die Liste xs aller Tupel (x, y, z) mit x, y, z ∈ N, so dass die Tupel in einer fairen Reihenfolge
erzeugt werden. Fair bedeutet hierbei, dass (a,b,c) ‘elem‘ xs für jedes Tupel von Zahlen
(a,b,c) nach endlicher Zeit terminiert.
(10 Punkte)
Aufgabe 3 (25 Punkte)
Implementieren Sie die folgenden Funktionen in Haskell im Wesentlichen unter Verwendung von List
Comprehensions, d.h. die entsprechende Implementierung sollte von der Form f xs = e sein, wobei
e eine List Comprehension ist, die xs verwendet. Die Verwendung von Pattern Matching und den
Listenfunktion map, filter und concat ist dabei verboten!
a) Eine Funktion f1, die eine Liste xs von Tripeln (a, b, cs) erhält, wobei a und b Ganzzahlen
sind und cs eine Liste von Zahlen ist. Die Funktion f1 erstellt daraus die Liste von Paaren
(a · b, b + c), für alle Elemente c aus cs, sodass nur solche Paare in der Ausgabe erscheinen, deren
erste Komponente echt größer als die zweite Komponente ist.
Z.B. soll f1 [(10,20,[1,10,100]), (4,5,[5,15,25])]
[(200,21),(200,30),(200,120),(20,10)] liefern.
als
Ergebnis
die Liste
(8 Punkte)
b) Eine Funktion f2, die eine Liste xs von Paaren erhält, wobei beide Paarkomponenten vom
gleichen Typ sind, und daraus eine Liste von Elementen erstellt, indem die Paarkomponenten
nacheinander in die Ergebnisliste eingefügt werden.
Z.B. soll f2 [(1,2),(3,4),(5,6)] als Ergebnis die Liste [1,2,3,4,5,6] erzeugen. (8 Punkte)
1
c) Eine Funktion f3, die eine Liste xs von Listen von Zahlen erhält, und aus den inneren Listen
alle Zahlen entfernt, die echt größer als 50 sind und anschließend alle Listen entfernt, die noch
mehr als 3 Elemente enthalten.
Z.B. soll f3 [[5,25,50,60],[48,49,50,51], [46,47,48,49,50]] als Ergebnis die Liste
[[5,25,50],[48,49,50]] erzeugen.
(9 Punkte)
Aufgabe 4 (25 Punkte)
Ein Stift sei durch die Attribute Stifttyp (Bleistift, Kugelschreiber, Füller oder Filzstift), Farbe
(schwarz, blau, grün oder rot) und Preis (als Kommazahl) charakterisiert. Stifte können daher in
Haskell durch die folgenden Datentypen modelliert werden1 :
data Stift
= Stift Stifttyp Farbe Preis
deriving(Eq,Show)
data Farbe
= Schwarz | Blau | Gruen | Rot
deriving(Eq,Show)
data Stifttyp = Bleistift | Kugelschreiber | Fueller | Filzstift
deriving(Eq,Show)
type Preis
= Double
Z.B. wird ein blauer Füller mit Preis EUR 8,50 dargestellt als (Stift Fueller Blau 8.5)
a) Implementieren Sie Zugriffsfunktionen
– getFarbe
:: Stift -> Farbe
– getStifttyp :: Stift -> Stifttyp
– getPreis
:: Stift -> Preis
die für einen Stift dessen Farbe, Stifttyp bzw. Preis extrahieren.
(6 Punkte)
b) Ein Mäppchen hat als Attribute eine Farbe und eine Liste von Stiften:
data Maeppchen = Maeppchen Farbe [Stift]
deriving(Eq,Show)
Implementieren Sie die folgenden Funktionen für Mäppchen:
(12 Punkte)
– wert :: Maeppchen -> Preis, welche die Preise aller im Mäppchen enthaltenen Stifte
summiert.
– roterKugelschreiber :: Maeppchen -> Bool, die prüft, ob das Mäppchen einen roten
Kugelschreiber enthält.
– fuelle :: Maeppchen -> [Stift] -> Maeppchen, die ein Mäppchen und eine Liste von
Stiften erhält und die Stifte dem Mäppchen hinzufügt.
c) Ein Lineal sei durch die Attribute Länge (als Integer-Zahl) und Preis (als Kommazahl) charakterisiert.
Entwerfen Sie einen Datentyp für Lineale in Haskell. Erweitern Sie anschließend den Datentyp
Maeppchen derart, dass ein Mäppchen höchstens ein Lineal enthalten kann und implementieren
Sie für den erweiteren Datentyp eine Funktion linealVorhanden :: Maeppchen -> Bool, die
prüft, ob im Mäppchen ein Lineal vorhanden ist.
(7 Punkte)
1
Die Zeile deriving(Eq,Show) führt dabei dazu, dass Objekte des entsprechenden Datentyps angezeigt und verglichen
werden können.
2