TDDC74 Lab 02 Listor, sammansatta strukturer 1 Översikt I denna laboration kommer ni att lära er mer om: Mer komplexa rekursiva mönster, procedurer och processer. Hur man kan hantera listor och andra enklare länkade strukturer. En klassisk sorteringsalgoritm. 2 Värt att veta Denna laboration består av en del med 14 fristående uppgifter. Alla problem måste lösas på ett tillfredsställande sätt för att laborationen ska bli godkänd. Utöver informationen i föregående laboration gäller att Laborationen berör kapitel 2 i kurslitteraturen. För mer läsning se även SICP+02 som finns på laborationssidan. Många av uppgifterna har ekvivalenta primitiver i Racket. Nyttja dessa för att kontrollera era lösningar. Ni ska kalla filen ni lämnar in för la02.rkt (kan man skönja ett mönster?). 1
3 Uppgifter Uppgift 1 ----------------------------------------------------------------------- Vi skriver följande definitioner i DrRacket. Vad för strukturer bildas? Förklara skillnaden mellan nedanstående definitioner för er själva. Det förväntas att dessa skillnader är självklara vid problem 10. (define foo (cons 2 3)) (define bar (list 2 3)) (define forex (cons 2 (cons 3 4))) (define tesco (list 2 bar)) (define adidas (list 2 (list 2 3))) Testa följande för egen del. (car foo)??? (car bar)??? (cdr foo)??? (cdr bar)??? (car (cdr forex))??? (car (cdr tesco))??? Rita hur parstrukturerna foo, bar forex, tesco ser ut (med box-pointerdiagram). Ni ska beskriva hur det ser ut efter att alla define-raderna evaluerats. Visa detta för din laborationsassistent, eller lämna in scannad version 1. Uppgift 2 ----------------------------------------------------------------------- Som uppvärmning skapar vi en funktion som räknar elementen i en lista. Implementera funktionen count-list som gör detta. > (count-list (1 2 3)) 3 > (count-list (1 2 (inner 3 4 5 6))) 3 > (count-list ()) 0 1 Skrivarna vid labbsalarna har gratis scanningfunktioner. 2
Notera att vi i denna uppgift bara räknar antalet element i huvudlistan. Vi går aldrig in i underlistor och räknar element där. Uppgift 3 ----------------------------------------------------------------------- Implementera en funktion keep-if som tar ett predikat och en lista som inargument och returnerar en ny lista endast innehållande de element i listan som uppfyllde predikatet. Ni ska inte undersöka listor-i-listor. > (keep-if even? (1 2 3 4)) (2 4) > (define two-list? (lambda (obj) (and (list? obj) (= (length obj) 2)))) > (keep-if two-list? (1 2 (1 2 3) (a b) (c d) x)) ;; listor med två element ((a b) (c d)) Uppgift 4 ----------------------------------------------------------------------- Skapa en funktion som tar ett naturligt tal n och en lista, och returnerar de n första elementen i en lista. Om listan är kortare än n ska hela listan returneras. > (first-n 3 (1 4 9 16 25)) (1 4 9) > (first-n 1 (1 4 9 16 25)) (1) > (first-n 999 (1 4 9 16 25)) (1 4 9 16 25) > (first-n 0 (1 4 9 16 25)) () > (first-n 2 (one (four (nine sixteen)) twentyfive)) (one (four (nine sixteen))) Uppgift 5 ----------------------------------------------------------------------- Definiera funktionen enumerate som returnerar en lista med tal från och med from till och med to med avstånd step. Indata är alltid heltal, och step > 0 och to from. 3
> (enumerate 1 6 1) (1 2 3 4 5 6) > (enumerate 1 1 1) (1) > (enumerate 1 1 2) (1) > (enumerate 1 8 2) (1 3 5 7) Uppgift 6 ----------------------------------------------------------------------- Att kunna vända en lista är en rätt grundläggande uppgift 2. Här ska vi implementera funktioner som skapar en kopia av listan, men i omvänd ordning. a) Implementera reverse-order-iter. Den ska vara iterativt rekursiv. > (reverse-order-iter (1 2 3 4 5)) (5 4 3 2 1) > (reverse-order-iter ((1 2) (3 4) 5)) ;; gå inte in i underlistor (5 (3 4) (1 2)) Notera att underlistorna som dök upp som element är helt oförändrade (så (1 2) har inte vänts). b) Implementera reverse-order-lin som en linjärt rekursiv funktion som tar en lista, och ger en version av listan i omvänd ordning. > (reverse-order-lin (1 2 3 4 5)) (5 4 3 2 1) > (reverse-order-lin ((1 2) (3 4) 5)) (5 (3 4) (1 2)) Uppgift 7 ----------------------------------------------------------------------- En klassisk byggsten inom funktionell programmering är map, som tar en funktion, något slags datastruktur, applicerar ( kör ) funktionen på varje element, och samlar ihop resultatet. I Racket kan man ta man en funktion 2 Och övning i att hantera parstrukturer. 4
( dubblera ett tal ) och en lista med värden (siffror), och ger tillbaka en lista med dubblerade tal. 3 Implementera en egen map-to-each-funktion. Den ska ta två argument: en procedur och en lista. Utdata ska vara resultatet av att funktionen applicerats på vart och ett av elementen i listan (för sig). > (map-to-each sqrt (1 4 9 25)) (1 2 3 5) Uppgift 8 ----------------------------------------------------------------------- Att data är sorterat är ofta avgörande för att kunna göra effektiva sökningar 4, eller för att vissa algoritmer ska kunna köras. I denna uppgift ska ni implementera funktionen insert-sort. Listan ska sorteras i stigande ordning med hjälp av insättningssortering 5. Ni behöver bara hantera listor som innehåller siffror. Det rekommenderas starkt att ni först skapar en procedur som tar ett element och en redan sorterad lista, och placerar in elementet på rätt plats i listan. Så här ska den fungera: > (insert-at-asc-place 2 (1 4 7)) (1 2 4 7) Därefter kan ni bygga vidare på detta tills ni får en färdig insertion sort. > (insert-sort (2 7 1 4)) (1 2 4 7) 3 I matematisk mening ger man bilden av listan under dubblerings-funktionen. Ordet map är just matematikens avbildning. 4 Överkurs (ej krav): Till exempel en binärsökning. Där letar man efter ett element genom att successivt dela listan på mitten fler och fler gånger. Om elementet vi letar efter är större än mittelementet, letar vi vidare i höger halva av listan. Eftersom listan är sorterad, vet vi att det måste finnas där, om det alls finns. Binärsökning i listor är dock inte effektivt att använda i Racket. Fundera gärna på varför. 5 http://en.wikipedia.org/wiki/insert_sort 5
3.1 Dubbelrekursion över listor Uppgift 9 ----------------------------------------------------------------------- Ett lite mer komplicerat exempel än keep-if är keep-if-all. Denna ska behålla alla värden som uppfyller predikatet. Om ett element som ska tas bort finns i en lista-i-listan spelar ingen roll. > (define (not-num? o) (not (number? o))) > (keep-if-all not-num? (one 2 three)) (one three) > (keep-if-all not-num? (one 2 (three 4) 5)) (one (three)) > (keep-if-all not-num? (one 2 (12) 5)) (one ()) Funktionen behöver inte kunna hantera vanliga par (så (1. 2) är inte giltigt indatai sig. Däremot kan det såklart vara ett element i en lista: > (keep-if-all pair? (1 2 (a. b) 3 (c. d) 4)) ((a. b) (c. d)) Som vanligt bygger vi upp nya strukturer, snarare än att ta bort i gamla. Fundera därför på vad resultatet borde vara när man stöter på olika slags data. Rita förslagsvis upp strukturerna ovan med box-pointer-diagram, eller skissa dem som träd. Uppgift 10 --------------------------------------------------------------------- Vi skriver en funktion reverse-all som tar en lista som kan innehålla listor. Funktionen ska returnera listan i omvänd ordning. Till skillnad från i reverse-funktionerna ska även underlistor vändas (och underlistor i underlistor, och underlistor i underlistor i underlistor...). Så här ska den fungera: > (reverse-all (1 2 3)) ;; vanlig lista (3 2 1) > (reverse-all (1 (3 2) 4)) ;; vänd underlista (4 (2 3) 1) > (reverse-all ((1 (a b)) (3 2) 4)) ; vänd underlistor, valfri nivå (4 (2 3) ((b a) 1)) Ni får välja linjärrekursiv/iterativ fritt. Ett tips kan vara att undersöka den iterativa först. Endast en lösning behöver lämnas in (men gör gärna båda!). 6
3.2 Dubbelrekursion, synsätt på sammansatta (träd)strukturer I Racket är listor bara parstrukturer. Listan (1 2) är samma sak som (1. (2. () )), det vi får vid (cons 1 (cons 2 (cons ()))). Ritar vi upp det så, beskriver det i någon mening ett träd: [..] / \ 1 [..] / \ 2 () Det här synsättet gör att vi (ofta) kan göra rätt eleganta programmeringslösningar, och behandla rekursion över träd. Den typen av strukturer som förgrenar sig, och hur man hanterar dem, är viktigt inom datavetenskapen (direkt eller indirekt, med hela den logiken dolt någonstans i en algoritm man använder). Ett kanske mer intressant exempel är ((1. 2) 3). Det motsvarar ( (1. 2). (3. ())). Sett som träd: [..] / \ [..] [..] / \ / \ 1 2 3 () Vi har alltså ett sätt att se det som konstanter, tomma listor/träd och par som sätts samman med cons. Det ger också lite av ledning om vilka fall vi har när vi behandlar strukturen. Uppgift 11 --------------------------------------------------------------------- I denna uppgift ska ni implementera count-all. Den ska fungera som tidigare, men dessutom klara av att hantera listor-i-listor, par-i-listor, konstanter, och andra typer av parstrukturer. Vi räknar alltså inte med att allt är äkta listor som slutar med (). > (count-all symbol) 1 > (count-all ()) 7
0 > (count-all (1. 2)) 2 > (count-all (1 2 3)) 3 > (count-all ((). 1)) 1 > (count-all (1. ())) 1 > (count-all (1 (2 (3 4)) 5)) 5 Vilka intressanta fall kan inträffa? Försök att göra kod med så få specialfall/villkor i cond som möjligt. Uppgift 12 --------------------------------------------------------------------- Att kunna bestämma om ett element förekommer i en parstruktur är en grundläggande operation. Skapa ett predikat, occurs? som returnar om dess första argument återfinns i en viss lista/parstruktur (som ovan!). Även jämförelser mellan rena atomer ska fungera. > (occurs? x x) > (occurs? x y) #f > (occurs? x (x. y)) > (occurs? x ((x. y). z)) > (occurs? x ((z. y). z)) #f > (occurs? x ()) #f Jämför din lösning i count-all och den i occurs? Vad är gemensamt? Vad skiljer? Uppgift 13 --------------------------------------------------------------------- Det är även bra att kunna byta ut element mot andra. Skapa subst-all som gör detta. Använd eqv? 6 för att jämföra om två objekt är samma. 6 http://docs.racket-lang.org/reference/eval-model.html#(part._model-eq) 8
Implementera subst-all enligt nedan: > (subst-all x y x) ;; klarar icke-sammansatta värden y > (subst-all x y ()) ;; klarar icke-sammansatta värden () > (subst-all () hej ()) ;; vi kan ersätta tomma listan hej > (subst-all x s (t e x c o)) (t e s c o) > (subst-all x s (t (r i (x) x) e)) (t (r i (s) s) e) > (subst-all x y (x. y)) ;; vanliga par (y. y) Uppgift 14 --------------------------------------------------------------------- Implementera predikatet tree-equal? som jämför två godtyckliga trädstrukturer som ovan och returnerar om de innehåller samma värden och har samma struktur. Indata kan potentiellt sett vara konstanter, innehålla listor-i-listor eller par. Ni får enbart gå igenom träden en gång. Ni kan alltså inte (till exempel) jämföra längden på dem. Indata kan innehålla godtycklig data, och ni ska använda eqv? för att jämföra element 7. > (tree-equal? (1. 2) (1. 2)) > (tree-equal? (1 2) (1 2)) > (tree-equal? (1 2) (1. 2)) ; ena är lista, andra par #f > (tree-equal? x x) > (tree-equal? x (x)) #f > (tree-equal? () ()) > (tree-equal? (1. 2) x) 7 http://docs.racket-lang.org/reference/booleans.html 9
#f > (tree-equal? x (1. 2)) #f 10
4 Testning och inlämning Även denna laboration finns det en färdig uppsättning av första tester att köra. Kopiera filen autotest-la02.rkt från katalogen /home/tddc74/lab/lab2 till er kurs/tddc74/lab2/-katalog. Se till att filen ligger i samma katalog som er kod. Skriv följande kod i början 8 av er labb-fil i Dr. Racket: (provide (all-defined-out)) Öppna sedan autotest-la02.rkt och kör den. Notera att raden (require la02.rkt") gör att det krävs att er fil heter så. Kör sedan autotest-filen. Får ni ett fel så läs vad felet säger! Det kan även vara intressant att ta en titt på hur autotest-filen ser ut inuti. Lämna sedan in med hjälp av send_lab-skriptet. Instruktion finns på labbsidan! 8 Plats är inte betydelsebärande. Det är bara en konvention. 11
5 Appendix A Nya tillåtna primitiver: car cdr cons eq? list? list require null? pair? symbol? eqv? let* first rest 12