Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 4 (Sortieren und Konstruktoren)

Transkript

1 Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wintersemester 2015/16) Wiederholungstutorium Lösungsblatt 4 (Sortieren und Konstruktoren) Hinweis: Dieses Übungsblatt enthält von den Tutoren für das Wiederholungstutorium erstellte Aufgaben. Die Aufgaben und die damit abgedeckten Themenbereiche sind für die Klausur weder relevant noch irrelevant. 1 Vergleichsprozeduren Aufgabe 4.1 (Case-Käse) Schreiben Sie eine Prozedur kaese: int string, die zu einer gegebenen Zahl eine Zeichenkette nach folgenden Regeln liefert. kaese 0 = " null " kaese 1 = " eins " kaese 2 = " zwei " Für alle anderen Zahlen soll kaese die Zeichenkette kaese liefern. Schreiben Sie kaese mit einem case Ausdruck. Lösung 4.1: fun kaese x = case x of 0 " null " 1 " eins " 2 " zwei " _ " kaese " Aufgabe 4.2 Betrachten Sie folgende case-struktur: case xs of nil 0 [(x,y)] x+y [(x,5), (7,y)] x*y (_::_:: xr) 1 Welche der Muster der 4 Regeln des case-ausdrucks treffen den Wert [(2, 5), (7, 3)]? An welche Werte werden die Variablen der Muster dabei gebunden? Aufgabe 4.3 (Lexikalische Ordnung für Listen) Schreiben Sie eine polymorphe Prozedur listcmp: (α * α order) α list * α list order, die zwei Listen gemäß einer Vergleichsprozedur lexikalisch vergleicht. Lösung 4.3: fun listcmp cmp ( nil, nil ) = EQUAL listcmp cmp ( xs, nil ) = GREATER listcmp cmp ( nil, ys) = LESS listcmp cmp (x::xr,y:: yr) = case cmp (x,y) of EQUAL listcmp cmp ( xr, yr) 1

2 s s Aufgabe 4.4 (Zeichenketten vergleichen) Schreiben Sie eine Vergleichsprozedur strcmp: string * string order, die zwei Zeichenketten gemäß der lexikalischen Ordnung vergleicht. Gehen Sie dazu wie folgt vor. (a) Schreiben Sie eine Vergleichsprozedur charcmp: char * char order, die zwei Zeichen gemäß ihrer Ordnungszahlen vergleicht. (b) Schreiben Sie strcmp unter Verwendung von charcmp und listcmp aus der vorherigen Aufgabe. Lösung 4.4: (a) fun charcmp (x,y) = Int. compare ( ord x, ord y) (b) fun strcmp ( x, y) = listcmp charcmp ( explode x, explode y) Aufgabe 4.5 (Member) Schreiben Sie eine polymorphe Prozedur member: (α * α order) α α list bool, die testet, ob ein gegebener Wert in einer Liste vorkommt. Lösung 4.5: fun member cmp x nil = false member cmp x (y:: yr) = case cmp (x,y) of EQUAL true s member cmp x yr 2 Sortieren Aufgabe 4.6 (Sortieren durch Einfügen) Verdeutlichen Sie sich den Algorithmus von Sortieren durch Einfügen und lösen Sie folgende Aufgaben. (a) Muss der Algorithmus für alle Argumente gleich viel Arbeit leisten? (b) Wenn nicht, wann ist der Algorithmus am effizientesten/ineffizientesten? Geben Sie Beispiele für Listen der Länge 5 an, die aufsteigend sortiert werden sollen. (c) Implementieren Sie Sortieren durch Einfügen durch eine Prozedur isort: int list int list, die eine Liste aus ganzen Zahlen strikt aufsteigend sortiert. (d) Implementieren Sie nun den Algorithmus polymorph unter Verwendung einer an pisort übergebenen Vergleichsprozedur cmp. Dabei soll pisort das Typschema (α * α order) α list α list besitzen und beliebige Listen aufsteigend sortieren. (e) Verdeutlichen Sie sich, wie die bereits fertige polymorphe Prozedur pisort jetzt verwendet werden kann, um eine andere Sortierprozedur (z.b. absteigend sortierend) zu erhalten. (f) Schreiben Sie eine Prozedur downsort: int list int list, die Listen von ganzen Zahlen absteigend sortiert. Verwenden Sie pisort. Lösung 4.6: (a) Nein, da in jedem Schritt in die bereits sortierte Teilliste von der zu sortierenden Liste die restlichen Elemente einsortiert werden, kommt es darauf an, an welcher Stelle diese einzufügen sind. 2

3 (b) sort [1,2,3,4,5] ist am ineffizientesten, da das einzusortierende Element in jedem Schritt am Ende der sortierten Teilliste einzufügen ist. Dahingegen ist sort [5,4,3,2,1] am effizientesten, da immer vorne eingefügt wird. (c) fun sort xs = let fun insert (x,nil ) = [x] insert (x,y:: yr) = if x<y then x::y:: yr else if x=y then y:: yr else y:: insert (x,yr) in foldl insert nil xs end (d) fun sort cmp xs = let fun insert (x,nil ) = [x] insert (x,y:: yr) = case cmp (x,y) of GREATER y:: insert (x,yr) _ x::y:: yr in foldl insert nil xs end (e) Die übergebene Vergleichsprozedur entscheidet darüber, wie die Elemente sortiert werden. (f) fun mycmp ( x, y) = if x<y then GREATER else if x>y then LESS else EQUAL val downsort = sort mycmp Aufgabe 4.7 (Sortieren durch Mischen) Schreiben Sie eine polymorphe Sortierprozedur pmsort: (α * α order) α list α list, die durch Mischen sortiert. Lösung 4.7: fun pmsort cmp nil = nil pmsort cmp [x] = [x] pmsort cmp xs = let fun split xs = foldl (fn (x,(us,vs )) (x::vs,us )) (nil, nil ) xs fun merge xs nil = xs merge nil ys = ys merge (x:: xr) (y:: yr) = case cmp (x,y) of GREATER y:: merge (x:: xr) yr EQUAL x::y:: merge xr yr LESS x:: merge xr (y:: yr) val (us,vs) = split xs in merge ( pmsort cmp us) ( pmsort cmp vs) end Aufgabe 4.8 (Für fleißige Meistersortierer oder zum überspringen) (a) Schreiben Sie eine Prozedur partition : int int list int list * int list die zu einer Zahl x und einer Liste xs zwei Listen us und vs wie folgt liefert: 1. sort(us@vs) = sort xs 2. Alle Elemente von us sind kleiner als x und alle Elemente von vs sind größer oder gleich x. Schreiben Sie partition mit foldl. (b) Schreiben Sie eine Prozedur qsort: int list int list, die Listen über int gemäß dem Algorithmus Quicksort sortiert. 3

4 Quicksort sortiert Listen gemäß der Prozedur partition, die eine Liste in zwei Teillisten zerlegt und ihre durch Rekursion berechnete Sortierung mit Konkatenation wieder zusammenfügt: qsort(x :: xr) = (qsort (qsort vs) (c) Schreiben Sie eine Prozedur ppartition : (α * α order ) α list α list * α list * α list die eine Liste xs gemäß einer Vergleichsprozedur f in drei Listen us, vs, ws zerlegt, sodass der Vergleich f für die Elemente von us LESS, von vs EQUAL und von ws GREAT ER liefert. (d) Knifflig! Implementieren Sie Quicksort mithilfe von ppartition polymorph. Lösung 4.8: (a) fun partition r xs = let fun spread (x,(us,vs )) = if x<r then (x::us,vs) else (us,x:: vs) in foldl spread ( nil, nil ) xs end (b) fun qsort nil = nil qsort (x:: xr) = let val (us,vs) = partition x xr in qsort qsort vs end (c) fun ppartition cmp r xs = let fun spread (x,(us,vs,ws )) = case cmp (x,r) of GREATER (us,vs,x:: ws) EQUAL (us,x::vs,ws) LESS (x::us,vs,ws) in foldl spread ( nil, nil, nil ) xs end (d) fun pqsort cmp nil = nil pqsort cmp (x:: xr) = let val (us,vs,ws) = ppartition cmp x xr in pqsort cmp [ pqsort cmp pqsort cmp ws end 4

5 3 Konstruktoren Aufgabe 4.9 (Osterschmuck mit Konstruktoren) Ihr bester Freund Dieter Schlau bereitet sich schon früh auf die Osterzeit vor. Er möchte bereits jetzt einen Osterstrauch festlich schmücken und plant dafür erstmal in SML, wie er dies realisieren könnte. Seien die Datentypen f arbe und strauch wie folgt gegeben: datatype farbe = GELB WEISS GRUEN datatype strauch = S of int Dabei zeigt f arbe, welche Farbe der Osterschmuck haben kann, mit dem man den Osterstrauch schmücken kann. Die ganze Zahl von strauch gibt an, wie viel Osterschmuck noch an den Strauch passt. Ignorieren Sie, dass man den Osterschmuck einfach etwas enger an den Osterstrauch hängen könnte. (a) Deklarieren Sie einen Datentyp schmuck, der den vorhandenen Osterschmuck darstellt. Osterschmuck besteht aus Ostereiern und kleinen Stoffschäfchen. Ostereier können alle gegebenen Farben haben. Für Stoffschäfchen braucht es keine Farbangabe, da diese immer weiß sind. (b) Deklarieren Sie eine Prozedur schaefchen: strauch strauch schmuck list, die einen Osterstrauch bekommt und eine Liste mit 8 Stoffschäfchen zurückgibt, zusammen mit den leer geblieben Ästen des Strauches (d.h. wenn der Eingabestrauch für 10 Schäfchen freie Äste hat, soll der Rückgabestrauch 2 freie Äste haben). Reicht der Strauch nicht mehr für 8 Schäfchen, so sollen nur so viele Schäfchen zurückgegeben werden wie Äste da sind, zusammen mit dem jetzt aufgebrauchten Platz, also S 0. (c) Wir können das Schmücken der Strauchs durch Prozeduren vom Typ strauch strauch schmuck darstellen. Hier soll der zurückgegebene Strauch für ein Schmuckstück weniger reichen als der Eingabestrauch. Falls der Eingabestrauch nicht mehr genug Platz für weiteren Schmuck hat, soll eine NotEnoughBoughs Exception geworfen werden. Definieren Sie einen Typ anhaengen, der das Schmücken des Strauches auf diese Weise darstellt. Hinweis: Sie sollen hier das Schlüsselwort type verwenden, nicht datatype. (d) Deklarieren Sie eine Prozedur verwandle : farbe anhaengen, die zu einer gegebenen Farbe eine Prozedur zurückgibt, die Ostereier der Farbe an einen Strauch hängt. (e) Deklarieren Sie eine Prozedur schmuecken : strauch farbe option strauch schmuck list, die ein Osterei der entsprechenden Farbe an den Strauch hängt. Falls die übergebene Farbe N ON E ist, sollen bis zu 8 Stoffschäfchen an den Strauch gehängt werden. Sollten während des Schmückens die Äste ausgehen, (es werden z.b. nur 5 Schäfchen an den Strauch gehangen), so soll die NotEnoughBoughs Exception geworfen werden. Bleiben Äste übrig, so soll diese zurückgegeben werden. (f) Und nun zum krönenden Abschluss: Deklarieren Sie eine Prozedur schmueckautonomous : strauch f arbe option list strauch schmuck list die (unter Verwendung von schmuecken) entsprechend der f arbe option list den Strauch schmückt und zurückgibt. Falls während des Schmückens die Äste ausgehen, sollen automatisch neue Äste hinzugestellt werden. Mit val newboughs = S 20 können immer neue Äste hinzugestellt werden. Es dürfen maximal 7 Äste weggeworfen werden, d.h. Sie dürfen sich nicht einfach für jeden Schmuckvorgang neue Äste nehmen. Lösung 4.9: (a) datatype schmuck = EIER of farbe STOFFSCHAEFCHEN (b) fun schaefchen ( S x) = iter ( Int. min (x,8)) ((S x), nil ) (fn ((S x),zs) (S (x 1), STOFFSCHAEFCHEN :: zs )) (c) exception NotEnoughBoughs type anhaengen = strauch strauch * schmuck (d) fun verwandle f ( S x) = if x=0 then raise NotEnoughBoughs else (S(x 1), EIER f) (e) fun schmuecken ( S x) NONE = if x < 8 then raise NotEnoughBoughs else schaefchen ( S x) schmuecken t ( SOME f) = let val ( a, b)=verwandle f t 5

6 in (a,[b]) end (f) fun schmueckautonomous t nil = ( t, nil ) schmueckautonomous t ( f:: fs) = let val ( a, b) = schmuecken t f handle NotEnoughBoughs schmueckautonomous newboughs ( f:: fs) val ( c, d) = schmueckautonomous a fs in (c,b@d ) end Aufgabe 4.10 (Natürliche Zahlen) Wir stellen die natürlichen Zahlen dar mit den Werten folgendes Konstruktortyps: datatype nat = O S of nat So ergibt sich z.b. 0 O, 1 SO, 2 S(SO), 3 S(S(SO)). (a) Deklarieren Sie eine Prozedur code: int nat, die die Darstellung einer natürlichen Zahl liefert und eine Prozedur decode: nat int, sodass decode (code n) = n für alle natürlichen Zahlen gilt. (b) Deklarieren Sie Prozeduren nat nat nat für folgende Berechnungen, ohne dabei Operationen für int zu verwenden: (i) Addition m + n. (ii) Multiplikation m n. (iii) Potenzierung m n. (iv) Kleiner-als m < n. Lösung 4.10: (a) fun code 0 = O code n = S ( code (n 1)) fun decode O = 0 decode ( S x) = 1 + decode x (b) (i) fun natadd O n = n natadd m O = m natadd (S m) (S n) = S ( natadd m (S n)) (ii) fun natmul O n = O natmul m O = O natmul (S m) (S n) = natadd (S m) ( natmul (S m) n) (iii) fun natpot O n = O natpot m O = S O natpot (S m) (S n) = natmul (S m) ( natpot (S m) n) (iv) fun natleq O O = false natleq O n = true natleq m O = false natleq (S m) (S n) = natleq m n Aufgabe 4.11 (Ziffern) Betrachten Sie folgenden Konstruktortyp, der natürliche Zahlen durch einzelne Ziffern darstellt: datatype digit = E of int M of int * digit So wird die Zahl 13 etwa durch M(1,E 3) dargestellt. (a) Geben Sie die Konstruktordarstellung der Zahl 9042 an. 6

7 (b) Schreiben Sie eine Prozedur stell: digit int zur Berechnung der Stelligkeit einer digit-zahl. (c) Schreiben Sie eine Prozedur rev: digit digit, die eine digit-zahl reversiert. Deklarieren Sie zunächst eine endrekursive Hilfsprozedur rev : digit digit digit. (d) Knifflig! Schreiben Sie eine Prozedur add: digit digit digit, die zwei digit-zahlen addiert. Verwenden Sie weder mod noch div. Orientieren Sie sich an dem schriftlichen Additionsverfahren, das Ziffern einzeln von rechts nach links zusammenzählt. Lösung 4.11: (a) M(9, M(0, M(4, E 2))) (b) fun stell ( E x) = 1 stell (M (x,m)) = 1 + stell m (c) fun rev (E z) = (E z) rev (M (z,e)) = let fun rev a (E z ) = M(z,a) rev a (M(z,d)) = rev (M(z,a)) d in rev (E z) e end (d) fun add d1 d2 = let fun add ( E z1) ( E z2) = if z1+z2 < 10 then ( E ( z1+z2 )) else (M(( z1+z2) 10,E 1)) add (M(z1,e)) (E z2) = if z1+z2 < 10 then (M(( z1+z2),e)) else (M(( z1+z2) 10, add e (E 1))) add (E z1) (M(z2,e)) = if z1+z2 < 10 then (M(( z1+z2),e)) else (M(( z1+z2) 10, add e (E 1))) add (M(z1,e)) (M(z2,h)) = if z1+z2 < 10 then (M(( z1+z2),add e h)) else (M(( z1+z2) 10, add (add e (E 1)) h)) in rev (add ( rev d1) ( rev d2 )) end Aufgabe 4.12 (Ausdrücke und Umgebungen) Wir betrachten folgende Deklaration für den Konstruktortyp exp. datatype exp = C of int V of string A of exp * exp M of exp * exp (a) Stellen Sie den Ausdruck (3x + 2)y durch die Werte des Konstruktortyps exp dar. (b) Schreiben Sie eine Prozedur subexps: exp exp list, die zu einem Ausdruck die Liste aller Teilausdrücke liefert. (c) Schreiben Sie eine Prozedur eval: (string int) exp int, die einen Ausdruck gegeben einer Umgebung auswertet. Die Umgebung wird dabei durch eine Prozedur string int realisiert, die Bezeichner an einen Wert bindet. Lösung 4.12: (a) M(A(M(C 3,V "x"),c 2),V "y") (b) fun subexps e = e ::( case e of A(e,e ) subexps subexps e M(e,e ) subexps subexps e _ nil ) (c) fun eval env ( V x) = env x eval env (C c) = c eval env (M(e,e )) = eval env e * eval env e eval env (A(e,e )) = eval env e + eval env e 7

8 4 Ausnahmen und Optionen Aufgabe 4.13 (Inception) Betrachten Sie folgendes Programm. Geben Sie das Typschema an. Zu was wertet die Prozedur aus? fun inception x = if null x then let exception Exception in Exception end else let val deception = tl x in inception ( deception ) end Lösung 4.13: Die Prozedur inception: α list exn gibt immer die Ausnahme Exception zurück. Aufgabe 4.14 (Someone?) Sei exception E of int vordeklariert. Sind folgende Programme gültig? Zu was werten sie aus? (a) ((fn x E x) (1 div 0); NONE) handle E x SOME x (b) ((fn x raise E x) 1; NONE) handle E x SOME x (c) ((fn E x x _ 0) (E 1); NONE) handle E x SOME x (d) (let exception F in raise E 1; NONE end) handle E x SOME x Welches der Programme bietet uns eine praktikable, funktionale Struktur zur Verwendung von Ausnahmen? Lösung 4.14: (a) uncaught exception Div (b) val it: SOME 1 Praktikabel und funktional zum Werfen und Fangen von Ausnahmen. (c) val it: NONE (d) val it: SOME 1 Aufgabe 4.15 (Auf Listen) (a) Schreiben Sie eine Prozedur last: α list α option, die das letzte Element einer Liste liefert. (b) Deklarieren Sie eine Prozedur length: α list int, die die Länge einer Liste bestimmt. Verwenden Sie keine Hilfsprozeduren außer hd und tl und verwenden Sie genau eine Regel für die Prozedur. (c) Schreiben Sie eine Prozedur double: (α * α order) α list α option, die eine Liste auf Mehrfachauftreten überprüft und gegebenenfalls das mehrfach auftretende Element als Option zurückgibt. (d) Schreiben Sie eine Prozedur find: (α * α order) α α list α option, die mithilfe einer Vergleichsprozedur prüft, ob ein Element x in einer Liste vorkommt. Ist dies der Fall, soll SOME x zurückgegeben werden, andernfalls N ON E. Lösung 4.15: (a) fun last nil = NONE last [x] = SOME x last (x:: xr) = last xr (b) fun length xs = 1 + length ( tl xs) handle Empty 0 (c) fun finddouble comp xs = let exception Double of α fun comp (x,y) = case comp (x,y) of EQUAL raise Double x v v in ( List. sort comp xs; NONE ) handle Double x SOME x 8

9 end (d) fun find cmp x nil = NONE find cmp x (y:: yr) = case cmp (x,y) of EQUAL SOME x _ find cmp x yr Aufgabe 4.16 (a) Schreiben Sie eine Prozedur optionizer: α option list α list, welche eine option-liste in eine Liste übersetzt. Sobald jedoch ein N ON E in der Liste auftritt, wird die bereits übersetzte Liste verworfen und ab dem NONE eine neue Liste aufgebaut. Zum Beispiel: optionizer[some a, NONE, SOME b] [b] (b) Schreiben Sie eine Prozedur multioptionater: (int option * int option) list int list, welche eine Liste aus int option-tupeln bekommt. Diese sollen miteinander multipliziert werden und in einer Liste ausgegeben werden. Befindet sich ein N ON E in einer Tupelkomponente, soll die Ausnahme urgh geworfen werden. Zum Beispiel: multioptionater[(some 4,SOME 0),(SOME 2,SOME 3),(SOME 1,SOME 4)] [0,6,4] Lösung 4.16: (a) fun optionizer xs = let fun opt nil ys = ys opt ( SOME x :: xr) ys = opt xr (x:: ys) opt ( NONE :: xr) ys = opt xr nil in opt xs nil end (b) exception urgh fun multioptionater xs = map (fn (x,y) case (x,y) of ( SOME x, SOME y) x*y _ raise urgh ) xs 9