Programmierung 1 (Wintersemester 2015/16) Lösungsblatt: Aufgaben für die Übungsgruppen: 5 (Kapitel 5)

Transkript

1 Fachrichtung 6.2 Informatik Universität des Saarlandes Tutorenteam der Vorlesung Programmierung 1 Programmierung 1 (Wtersemester 2015/16) Lösungsblatt: Aufgaben für die Übungsgruppen: 5 (Kapitel 5) Hweis: Dieses Übungsblatt enthält von den Tutoren für die Übungsgruppe erstellte Aufgaben. Die Aufgaben und die damit abgedeckten Themenbereiche sd für die Klausur weder relevant noch irrelevant. 1 Vergleichsprozeduren Aufgabe 5.1 (Vergleichsprozeduren) (a) Warum brauchen wir Vergleichsprozeduren? Erklären Sie! (b) Dieter Schlau behauptet: Ee jede Vergleichsprozedur muss vom Typ α α order se! Stimmt das? Lösung 5.1: (a) Wir benötigen Vergleichsprozeduren, um polymorphe Sortieralgorithmen implementieren zu können. Ee Vergleichsprozedur ist ee Prozedur, die zwei Elemente ees Typs nimmt und - gemäß unserer Vorstellung von Größe - zurückgibt, ob das erste Elemente kleer / gleich / größer dem zweiten Element se soll. (b) Ne, wir benötigen keen Typ mit Gleichheit. E denkbares Gegenbeispiel wäre die gültige Vergleichsprozedur fun comp (x : α, y : α) = EQUAL, die alle Elemente als gleich ansieht und selbstverständlich keen Typ mit Gleichheit erfordert. Aufgabe 5.2 Schreiben Sie ee Vergleichsprozedur co, welche alle Elemente als gleich ansieht. Zu was wertet ssort co xs aus, wenn ssort ee Implementierung ees beliebigen strikten Sortieralgorithmus und xs ee beliebige Liste ist? Lösung 5.2: fun co (x,y) = EQUAL Wenn xs die leere Liste ist, wertet es zu nil aus. Ansonsten zu eer eelementigen Liste, die irge Element von xs enthält. Aufgabe 5.3 Schreiben Sie ee Vergleichsprozedur vstrg: strg * strg order, welche die lexikalische Ordnung auf strg herumdreht. So wäre z.b. ["Zebra", "Zahltag", "Banane", "Affe"] ee korrekt sortierte Liste, nach dieser Vergleichsprozedur. Lösung 5.3: fun vstrg (x,y) = Strg. compare (y,x) Aufgabe 5.4 (a) Implementieren Sie ee Prozedur triplecompare, welche die lexikalische Ordnung auf Tripeln des Typs t * strg * real angibt. (b) Schreiben Sie nun ee Sortierprozedur tripsort, welche ee Liste von Tripeln obigen Typs nach der lexikalischen Ordnung sortiert. Sie können Ihr Lieblgssortierverfahren benutzen. 1

2 Lösung 5.4: (a) fun triplecompare ((i,s,r),(a,b,c)) = if i=a then ( case Strg. compare (s,b) of EQUAL Real. compare (r,c) x x) else Int. compare (i,a) (b) fun split xs = foldl (fn (x,(l,s)) (s, x::l)) (nil, nil ) xs fun merge c xs nil = xs merge c nil ys = ys merge c (x:: xr) (y:: yr) = ( case c (x,y) of GREATER y ::( merge c (x:: xr) yr) _ x ::( merge c xr (y:: yr ))) fun msort c [] = [] msort c [x] = [x] msort c xs = let val ( ls, rs) = split xs merge c ( msort c ls) ( msort c rs) val tripsort = msort triplecompare Aufgabe 5.5 Gegeben sei ee Prozedur below: α * α bool, die für zwei Elemente, x und y, entscheidet, ob x < y gilt. Reicht das aus, um alle Vergleiche richtig entscheiden zu können? Schreiben Sie ee Prozedur compare: α * α order, die zwei Elemente entsprech vergleicht. Lösung 5.5: Ja, da edeutig festgelegt ist, wann zwei Elemente kleer bzw. größer sd. Trifft kes von Beidem zu, sd die Elemente gleich. fun compare (x,y) = if below (x,y) then LESS else if below ( y, x) then GREATER else EQUAL Aufgabe 5.6 (a) Schreiben Sie ee Prozedur pair: (t * bool) * (t * bool) (t * bool), die zwei Paare miteander vergleicht und das größere ausgibt. Hierfür soll zunächst die erste Komponente der beiden Paare miteander verglichen werden. Unterscheiden sich die beiden Paare dieser Komponente nicht, so soll das Paar, dessen zweite Komponente true ist, ausgegeben werden. Sd beide Paare äquivalent, soll die Ausnahme Samepair geworfen werden. (b) Schreiben Sie ee Prozedur listcomp: (bool list) * (bool list) order, die zwei Listen miteander vergleicht. Dabei soll true > false gelten. Beispielsweise soll listcomp ([true, false], [false, true, true]) zu GREATER auswerten. Lösung 5.6: (a) exception Samepair fun pair ((a,b),(x,y)) = case Int. compare (a,x) of LESS (x,y) GREATER (a,b) EQUAL ( case (b,y) of (true, false ) (a,b) ( false, true ) (x,y) (_,_) raise Samepair ) (b) fun listcomp ( nil, nil ) = EQUAL listcomp ( nil,_) = LESS 2

3 listcomp (_, nil ) = GREATER listcomp (x::xs,y:: ys) = ( case (x,y) of (true, false ) GREATER ( false, true ) LESS _ listcomp (xs,ys )) 2 Sortieren Aufgabe 5.7 Geben Sie den Rekursionsbaum von Merge-Sort für die Liste [3,1,4,7,4,5,2] an. Lösung 5.7: Hweis: Wenn die Liste ungerade Länge hat, steht das erste Element hten der rechten Teilliste, bei gerader Länge der lken. [3,1,4,7,4,5,2] [5,7,1] [2,4,4,3] [7] [1,5] [4,2] [3,4] [1] [5] [4] [2] [3] [4] Aufgabe 5.8 Schreiben Sie ee Prozedur sort: t list t list, die ee Liste aufsteig sortiert, und zwar derart, dass gerade Zahlen vor ungeraden Zahlen auftauchen. So soll z. B. sort [4, 3, 9, 0, 2, 7] die Liste [0, 2, 4, 3, 7, 9] zurückgeben. Lösung 5.8: fun sort xs = let val even = List. filter ( fn x x mod 2 = 0) xs val odd = List. filter ( fn x x mod 2 = 1) xs ( List. sort ( Int. compare ) even ( List. sort ( Int. compare ) odd ) Aufgabe 5.9 Schreiben Sie ee Prozedur almost: t t list bool, die für ee Liste prüft, ob dieser alle Zahlen, die strikt größer als ee übergebene Zahl sd, aufsteig sortiert sd. Beispielsweise soll almost 3 [4,1,8,3,2,11] zu true auswerten. Lösung 5.9: fun almost _ nil = true almost _ [_] = true almost n (x::y:: xr) = if x <= n then almost n (y:: xr) else if y <= n then almost n ( x:: xr) else if x < y then almost n ( y:: xr) else false 3

4 Aufgabe 5.10 Gegeben sei ee Prozedur sorted: α list bool, die genau dann true liefert, wenn die übergebene Liste aufsteig sortiert ist. (a) Geben Sie den Typ eer Prozedur fallg an, die mithilfe von sorted testet, ob ee Liste absteig sortiert ist. (b) Schreiben Sie die Prozedur fallg. Benutzen Sie dabei kee weiteren Hilfsprozeduren oder Listenprozeduren außer sorted. Lösung 5.10: (a) α list bool (b) fun fallg nil = true fallg [_] = true fallg (x::y:: xr) = if sorted [x,y] then false else fallg (y:: xr) Aufgabe 5.11 (a) Lösen Sie die Aufgaben 5.11 und 5.12 auf Seite 105 im Buch, um den Sortieralgorithmus Quicksort kennenzulernen. (b) Schreiben Sie ee Prozedur quicksort3: t list t list, die ee Liste wie Quicksort sortiert, aber die Liste nicht zwei, sondern drei Teillisten zerlegt. Nehmen Sie statt nur dem ersten, die ersten beiden Elemente als Trennelemente (Pivotelemente). (c) Passen Sie quicksort3 so an, dass es polymorph wird ((α * α order) α list α list) und ee Prozedur vergleich: α * α order zum Vergleichen nimmt. Lösung 5.11: (a) fun partition m max xs = let fun zuordnen (n, (a,b,c)) = if n <= m then (n::a,b,c) else if n <= max then (a,n::b,c) else (a,b,n::c) foldl zuordnen ( nil, nil, nil ) xs fun quicksort3 nil = nil quicksort3 [x] = [x] quicksort3 (x::y:: xr) = let val (m, max ) = if x <= y then (x,y) else (y,x) val ( bs, cs, ds) = partition m max xr ( quicksort3 bs)@[ m ]@( quicksort3 cs)@[ max ]@( quicksort3 ds) (b) fun partition vergleich m max xs = let fun zuordnen (n, (a,b,c)) = ( case vergleich (n,m ) of LESS (n::a,b,c) _ ( case vergleich ( n, max ) of LESS (a,n::b,c) _ (a,b,n::c))) foldl zuordnen ( nil, nil, nil ) xs fun quicksort3 _ nil = nil quicksort3 _ [x] = [x] quicksort3 vergleich ( x:: y:: xr) = let val (m, max ) = ( case vergleich (x,y) of 4

5 Abbildung 1: Bead Sort GREATER (y,x) _ (x,y)) val ( bs, cs, ds) = partition vergleich m max xr ( quicksort3 vergleich bs)@[ m ]@ ( quicksort3 vergleich cs)@[ max ]@ ( quicksort3 vergleich ds) Aufgabe 5.12 In dieser Aufgabe lernen Sie een neuen Sortieralgorithmus kennen. Ziel wird es se, ee Prozedur smallsort: (α * α order) α list α list zu schreiben, die ee Liste sortiert, dem sie immer das kleste Element der unsortierten Liste sucht, dieses aus der ursprünglichen Liste löscht und rechts an die schon sortierte Liste anhängt. Gerne dürfen Sie eigene Lösungsansätze verfolgen oder folgen Sie den Schritten. (a) Diskutieren Sie die Funktionsweise mit Ihren Kommilitonen oder fragen Sie Ihren Tutor bei Problemen. (b) Schreiben Sie zunächst ee Prozedur drop: (α * β order) α β list β list, die das erste Vorkommen ees übergebenen Wertes anhand eer Vergleichsprozedur aus eer Liste löscht. Wenn die Liste leer ist, soll die Ausnahme Subscript geworfen werden. (c) Schreiben Sie nun smallsort. Lösung 5.12: (b) fun drop compare x nil = raise Subscript drop compare x (y:: ys) = ( case compare (x,y) of EQUAL ys _ y ::( drop compare x ys )) (c) fun smallsort _ nil = nil smallsort compare xs = let val smallest = foldl (fn (x,y) case compare (x,y) of LESS x _ y) (hd xs) xs ( smallest ::( smallsort compare ( drop compare smallest xs ))) Aufgabe 5.13 (BeadSort) In dieser Übungsaufgabe wird der Sortieralgorithmus BeadSort vorgestellt, der ee t list absteig sortiert. 5

6 (a) Gegeben sei die t list : [3, 3, 1, 4, 2]. Stellen Sie sich parallele Stangen vor, auf denen Bälle aufgespießt sd. Dabei gibt es genauso viele Stangen wie der Wert des größten Elements. In unserem Fall vier. Reihen gibt es genauso viele wie es Elemente gibt. Siehe Abbildung 1 lks. Nun erlaubt man den Bällen herunterzuf allen. Zählt man nun die Bälle den Reihen ergibt sich die passe absteige Sortierung, siehe Abbildung rechts. Man erhält die tlist : [4, 3, 3, 2, 1]. Machen Sie sich klar, warum dadurch sortiert wird. (b) Schreiben Sie ee Prozedur notnull : α list bool, die testet, ob ee Liste e Element enthält. Nutzen Sie dafür null. (c) Schreiben Sie ee Prozedur replicate : t α α list, die gegeben eer natürlichen Zahl n und ees beliebigen x ee Liste ausgibt, die x genau n mal enthält. Z.B. soll replicate 3 ([1, 2]) die Liste [[1, 2], [1, 2], [1, 2]] ausgeben. (d) Schreiben Sie ee Prozedur columns : α list list α list list, die die α Elemente aus den Listen ihrer Position entsprech den anderen zuordnet. Nutzen Sie dafür List.f ilter, notnull (siehe oben), map und sowohl hd, als auch tl, oder gerne auch een eigenen Lösungsansatz! Z.B. soll columns[[1, 2, 3], [4, 5, 6], [7, 8]] die Liste [[1, 4, 7], [2, 5, 8], [3, 6]] ausgeben. Machen Sie sich die Funktionsweise von columns genau klar, fragen Sie nach, testen Sie unterschiedlichste Beispiele durch oder besprechen Sie Probleme mit Kommilitonen. (e) Schreiben Sie mithilfe von replicate ee Prozedur nureser : t list t list list, die aus eer Liste von teger ee Liste ausgibt, welche Listen nur mit dem Element 1 enthält, wobei die Länge der Liste die Größe des teger repräsentiert. z.b. soll nureser[3, 3, 1, 4, 2] die Liste [[1, 1, 1], [1, 1, 1], [1], [1, 1, 1, 1], [1, 1]] ausgeben. Betrachten Sie das Beispiel Verbdung mit Abbildung 2 lks. (f) Sie dürfen nun lich die Prozedur beadsort : t list t list schreiben, hierzu muss zunächst auf die Argument-Liste die Prozedur nureser angewet werden. Wie (Tipp: und wie oft?) müssen Sie nun die Prozeduren columns und length s Spiel brgen um das gewünschte Ergebnis zu erzielen? (g) Zusatz zur Entspannung. Ihre Liste wird nun absteig sortiert. Fügen Sie Ihre Implementierung von beadsort ee schnellereversion hzu, sodass die Liste danach auf steig sortiert ist. Lösung 5.13: (a) (b) fun notnull xs = if null xs then false else true (c) fun replicate n x = List. tabulate ( n, fn _ x) (d) fun columns xs = case List. filter notnull xs of [] [] xs ( map hd xs) :: ( columns ( map tl xs )) (e) fun nureser xs = map ( fn x replicate x 1) xs (f) fun beadsort xs = map length ( columns ( columns ( nureser xs ))) Warum muss columns zweimal angewet werden? Betrachten Sie folgen Output von Alice und testen Sie selbst herum. nureser [3,3,1,4,2]; val it : t list list = [[1,1,1], [1,1,1], [1], [1,1,1,1], [1,1]] > columns it; val it : t list list = [[1,1,1,1,1], [1,1,1,1], [1,1,1], [1]] > map length it; val it : t list = [5,4,3,1] Alternativ kann columns auch nur emal angewet werden. Die Länge der Liste ist dann der größte Wert. In unserem Fall 4. Dann entfernt man rekursiv das erste Element der t-listen und erhält so den nächstkleeren Wert als Länge der neu entstandenen Liste. Allerdgs müssen Sie darauf achten, leere Listen zu löschen. 6

7 fun beadsort xs = let fun deletenils xs = List. filter notnull xs fun anwen nil = nil anwen xs = length xs :: anwen ( foldl (fn(x,s) (tl x ):: s) nil ( deletenils xs )) anwen ( columns ( nureser xs )) 3 Mengen Aufgabe 5.14 Seien Mengen als Listen dargestellt. Sei cut als Operation defiert, die zu eem gegebenen Element x aus eer Menge M alle Elemente y entfernt, für die gilt: y > x. (a) Geben Sie den Typ eer Prozedur greatest an, die cut für liche Mengen implementiert. (b) Schreiben Sie greatest. Lösung 5.14: (a) (α * α order) α α list α list (b) fun greatest nil = nil greatest compare x ( y:: yr) = ( case compare (x,y) of LESS greatest compare x yr _ y:: greatest compare x yr) Aufgabe 5.15 Seien liche Mengen durch Listen dargestellt. Schreiben Sie ee Prozedur cross: (α * α order) α list α list (α * α) list, die das Kreuzprodukt zweier Mengen liefert: A B. Dabei soll die Rückgabe gemäß der durch die übergebene Vergleichsprozedur implizierten lexikalischen Ordnung sortiert se. Es gilt: A =. Sei ee Prozedur sort: ((α * β) * (α * β)) order) (α * β) list (α * β) list, die sortiert, gegeben. Lösung 5.15: fun cross nil = nil cross _ nil _ = nil cross vergleich ( x:: xr) ys =let fun crossvergleich ((a,b),(c,d)) = ( case vergleich (a,c) of EQUAL vergleich (b,d) s s) sort crossvergleich ( map ( fn y ( x, y)) cross vergleich xr ys) Aufgabe 5.16 Schreiben Sie ee Prozedur isset: α list bool, die entscheidet, ob ee übergebene Liste ee Menge vom Typ α darstellt. Listen stellen genau dann ee Menge dar, wenn sie kee Mehrfachauftreten enthalten. 7

8 Lösung 5.16: fun member _ nil = false member a ( x:: xr) = a = x orelse member a xr fun isset nil = true isset ( x:: xr) = not ( member x xr) andalso isset xr Aufgabe 5.17 Sei M ee beliebige Menge. Zwei Prädikate p und q auf M heißen äquivalent genau dann, wenn x M.p x q x. (a) Wie können wir zwei Prädikate p: α bool und q: α bool SML auf Äquivalenz prüfen? Für A M bezeichnen wir p und q als äquivalent auf A genau dann, wenn x A.p x q x. (b) Schreiben Sie ee Prozedur equi: (α bool) (α bool) α list bool, die für ee Menge A M mit n N. A = n entscheidet, ob p und q lokal äquivalent auf A sd. Lösung 5.17: (a) Gar nicht, da wir dafür im Allgemeen bis zu unlich viele Vergleiche durchführen müssten (Divergenz). (b) fun equi nil = true equi p q ( x:: xr) = p x = q x andalso equi p q xr Aufgabe 5.18 Ähnlich zu Intervallen auf den ganzen Zahlen (z.b. [ 14, 8]), können zwei beliebige Elemente des gleichen Typs, a und b, e Intervall aufspannen: [a, b]. (a) Gibt es Voraussetzungen, um testen zu können, ob e Element x im Intervall [a, b] liegt? (b) Geben Sie den Typ eer Prozedur tervall an, die testet, ob e Element x [a, b] liegt. (c) Deklarieren Sie die Prozedur tervall. Beachten Sie, dass beispielsweise das Intervall [5, 3] leer ist. (d) Geben Sie den Typ eer Prozedur countervall an, die zählt, wie viele Elemente eer Liste nerhalb ees Intervalls liegen. (e) Schreiben Sie die Prozedur countervall mithilfe von Musterabgleichen. (f) Schreiben Sie die Prozedur countervall mithilfe von Faltung. Lösung 5.18: (a) Ja, wir benötigen ee Vergleichsprozedur α * α order. Damit können wir prüfen, ob a x und x b. (b) α α (α * α order) α bool (c) fun tervall m max vergleich x = case ( vergleich (m, max ), vergleich (m, x), vergleich (x, max )) of ( GREATER,_,_) false (* leeres Intervall *) (_,GREATER,_) false (* x < m *) (_,_, GREATER ) false (* x > max *) _ true (d) α α (α * α order) α list t (e) fun countervall _ nil = 0 countervall m max comp ( x:: xr) = ( if tervall m max comp x then 1 else 0) + countervall m max comp xr (f) fun countervall m max comp xs = foldl ( fn ( x, a) a + ( if tervall m max comp x then 1 else 0)) 0 xs 8