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 2014
Aufgabenblatt Nr. 4
Abgabe: Mittwoch 14. Mai 2014 vor! der Vorlesung
Aufgabe 1 (20 Punkte)
Berechnen (Rechenweg erforderlich!) 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 := \y -> if (x y) then ((\w -> w) y) else ((\z -> z) z)
b) s2 := let g x = (\x -> \y -> (g y)) in let w = g u (g y), z = w in g
Aufgabe 2 (30 Punkte)
Geben Sie jeweils List Comprehensions in Haskell an, welche die folgenden Listen erzeugen:
a) Die unendliche Liste aller Zahlen n (n ∈ N), die durch 8, aber nicht durch 3 teilbar sind.
(6 Punkte)
b) Die drei RGB-Farben seien durch folgenden Datentyp in Haskell definiert:
data RGB = R | G | B
deriving(Eq,Show)
Geben Sie drei List Comprehensions an, die alle die (endliche) Liste aller 3-Tupel (x, y, z) für
alle x ∈ {1, 2, . . . , 1000}, y ∈ {True, False} und z ∈ {R, G, B} erzeugen, jedoch in den folgenden
drei verschiedenen Reihenfolgen:
(je 4 Punkte)
– Zähle erst alle Farben durch, dann die Wahrheitswerte und danach die Zahlen, d.h. die
Ausgabe beginnt wie folgt:
[(1,True,R), (1,True,G), (1,True,B), (1,False,R), (1,False,G), (1,False,B),
(2,True,R), (2,True,G), ...
– Zähle erst die Wahrheitswerte durch, dann die Farben und danach die Zahlen, d.h. die
Ausgabe beginnt wie folgt:
[(1,True,R), (1,False,R), (1,True,G), (1,False,G), (1,True,B), (1,False,B),
(2,True,R), (2,False,R), ...
– Zähle erst die Zahlen durch, dann die Farben und danach die Wahrheitswerte, d.h. die
Ausgabe hat die Form:
[(1,True,R), (2,True,R), ..., (1000,True,R),
(1,True,G), (2,True,G), ..., (1000,True,G),
(1,True,B), (2,True,B), ..., (1000,True,B),
(1,False,R), (2,False,R), ..., (1000,False,R),
(1,False,G), (2,False,G), ..., (1000,False,G),
(1,False,B), (2,False,B), ..., (1000,False,B)]
c) Die unendliche Liste xs aller 4-Tupel (a, b, c, d) mit a, b, c, d ∈ N, so dass die Tupel in einer fairen
Reihenfolge erzeugt werden. Fair bedeutet hierbei, dass (a,b,c,d) ‘elem‘ xs für jedes Tupel
von Zahlen (a,b,c,d) nach endlicher Zeit terminiert.
(12 Punkte)
1
Aufgabe 3 (20 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 in Funktionsargumenten und den Listenfunktionen map, filter und concat ist dabei verboten!
a) Eine Funktion f1, die eine Liste xs von Paaren (a, bs) erhält, wobei jeweils a eine Ganzzahl und
bs eine Liste von Zahlen ist. Die Funktion f1 erstellt daraus die Liste von Paaren (a, a + b), für
alle Elemente b aus bs, sodass nur solche Paare in der Ausgabe erscheinen, wenn a echt größer
als das Doppelte von b ist.
Z.B. soll f1 [(10,[1,2,3]), (6,[2,3,4]), (30,[10,20])]
[(10,11),(10,12),(10,13),(6,8),(30,40)] liefern.
als
Ergebnis
die Liste
(8 Punkte)
b) Eine Funktion f2, die eine Liste xs von Listen von Zahlen erhält, und zunächst in den inneren
Listen alle geraden Zahlen entfernt, danach alle inneren Listen entfernt, die noch mehr als 2
Elemente enthalten und anschließend alle verbleibenden Zahlen in den maximal zweielementigen
Listen in eine (flache) Liste einfügt.
Z.B. soll f2 [[1,2,3,4,5],[6,7,8,9],[10,11,12]] als Ergebnis die Liste [7,9,11] erzeugen.
(12 Punkte)
Aufgabe 4 (30 Punkte)
Ein Computer sei durch die Attribute Gerätetyp (Server,Desktop,Laptop oder Tablet), Hauptspeicher
(als Ganzzahl in GB), Prozessoren (als Liste, die für jeden Prozessor dessen Taktfrequenz als Ganzzahl
in MHz angibt) und seinen Wert (als Kommazahl in EUR) charakterisiert.
Computer können daher in Haskell durch die folgenden Datentypen modelliert werden1 :
data Computer
= Computer Geraet Speicher [Taktfrequenz] Wert
deriving(Eq,Show)
data Geraet
= Server | Desktop | Laptop | Tablet
deriving(Eq,Show)
type Speicher
= Integer
type Taktfrequenz = Integer
type Wert
= Double
Z.B. wird ein Laptop mit 4 GB Hauptspeicher einem Doppelkernprozessor mit jeweils 2000 MHz Taktfrequenz im Wert von 399,99 EUR als (Computer Laptop 4 [2000,2000] 399.99) dargestellt.
a) Implementieren Sie Zugriffsfunktionen
– getTyp :: Computer -> Geraet
– getSpeicher :: Computer -> Speicher
– getProzessoren :: Computer -> [Taktfrequenz]
– getWert :: Computer -> Wert
1
Die Zeile deriving(Eq,Show) führt dabei dazu, dass Objekte des entsprechenden Datentyps angezeigt und verglichen
werden können.
2
die für einen Computer dessen Gerätetyp, Speichergröße, Prozessorenbeschreibung bzw. Wert
extrahieren.
(6 Punkte)
b) Ein Computerladen hat als Attribute einen Inhaber (als String) und eine Liste von Computern:
data Computerladen = Computerladen Inhaber [Computer]
deriving(Eq,Show)
type Inhaber = String
Implementieren Sie die folgenden Funktionen für Computerläden:
– wert :: Computerladen -> Wert, welche die Summe der Werte aller im Laden
verfügbaren Computer berechnet.
(4 Punkte)
– anzahlServerMitVierProzessoren :: Computerladen -> Integer, die ausrechnet wievele Server mit genau vier Prozessoren im Laden verfügbar sind.
(6 Punkte)
– liefere :: Computerladen -> [Computer] -> Computerladen, die einen Computerladen und eine Lieferung von Computern erhält und den Computerladen aktualisiert, so dass
die neuen Computer hinzugefügt werden.
(6 Punkte)
c) Ein Monitor sei durch die Attribute Diagonale (als Integer-Zahl in Zoll) und Wert (als Kommazahl) charakterisiert.
Entwerfen Sie einen Datentyp für Monitore in Haskell. Erweitern
ßend den Datentyp Computerladen derart, dass auch Monitore neben
tern erfasst werden. Implementieren Sie für den erweiterten Datentyp
wertDerMonitore :: Computerladen -> Wert, die den Gesamtwert der
Laden berechnet.
3
Sie anschlieden Compueine Funktion
Monitore im
(8 Punkte)