TDDC74 Lab 02 – Listor

TDDC74 Lab 02 – Listor 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. • Enklare testning mot referensimplementation. • 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, laboration 2A

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 (define (define (define

foo (cons 2 bar (list 2 forex (cons tesco (list

3)) 3)) 2 (cons 3 4))) 2 bar))

Testa följande för egen del. (car (car (cdr (cdr (car (car

foo) bar) foo) bar) (cdr (cdr

−→ ??? −→ ??? −→ ??? −→ ??? forex)) −→ ??? tesco)) −→ ???

Till denna uppgift ska ni redovisa en skiss på hur parstrukturerna foo, bar forex, tesco ser ut (med box-pointer-diagram). Ni ska beskriva hur det ser ut efter att alla fyra define-raderna evaluerats. Rita inga nya strukturer, om det inte uttryckligen skapas några nya strukturer! Ni kan redovisa detta på papper vid labbtillfället, inlämnat i labbomslag, eller som scannad bildfil. Skrivarna vid labbsalarna har gratis scanningfunktioner.

Uppgift 2 ----------------------------------------------------------------------Det är ofta användbart att kunna kontrollera om något är ett atomiskt värde, data som inte är sammansatta på något vis. I våra fall, där vi bygger listor och träd med cons, räknar vi en atom som det som varken är ett par eller den tomma listan. Implementera predikatet atom? som testar om något är ett atomiskt värde. (atom? 1) −→ #t (atom? ’a) −→ #t 2

(atom? (null? (atom? (atom?

’(1 2 3)) −→ #f ’()) −→ #t ’()) −→ #f ’(2 . 3)) −→ #f

Uppgift 3 ----------------------------------------------------------------------Del 3A 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 4 9 16)) −→ 4 (count-list ’(1 (inner 3) 4)) −→ 3 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.

Del 3B Ni kan testa er funktion genom att jämföra resultatet mot length med samma argument. Om er funktion är korrekt skriven, ska den och length alltid ge samma svar. Skriv ett predikat count-list-correct? som tar en lista och testar om de ger samma svar.1 Bifoga ett par representativa körexempel.

Uppgift 4 ----------------------------------------------------------------------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 behöver inte undersöka listor-i-listor. (keep-if even? ’(1 2 3 4)) −→ (2 4) (keep-if (lambda (obj) (not (number? obj))) ’(one 2 three 4)) −→ (one three) (keep-if (lambda (obj) (and (list? obj) (= (length obj) 2))) ’(1 2 (1 2 3) (a b) (c d) x)) −→ ((a b) (c d)) 1

length används här som en referensimplementation. Det är inte ett ord som ni behöver kunna till tentan, men det är relevant i utveckling. I denna uppgift jämför vi funktioner som är i stort sett likvärdiga, vilket kan verka meningslöst. Tänk isåfall på fallet där vi har en gammal, långsam men fungerande algoritm och försöker utveckla en ny. Den gamla kan tjäna som referens.

3

Implementera även keep-if-correct? som tar ett predikat, en lista, och jämför resultatet med utdata från er funktion, med det från filter.

Uppgift 5 ----------------------------------------------------------------------Del 5A Skapa en funktion som 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 7 ’(1 4 9 16 25)) −→ (1 4 9 16 25) (first-n 2 ’(1 (4 9) 16 25)) −→ (1 (4 9)) (first-n 2 ’(one (four (nine sixteen)) twentyfive)) −→ (one (four (nine sixteen))) (first-n 4 (build-list 100000 values)) −→ (0 1 2 3) OBS! Argumentordning.

Del 5B I Racket finns funktionen take, som tar de n första elementen ur en lista. (take ’(a b c d e f) 3) −→ (a b c) Pröva ett par exempel, och undersök om take och first-n skiljer sig åt på något sätt. Implementera first-n-correct? som tar ett antal element, en lista och kontrollerar om first-n ger några felaktiga svar. Se till att first-n-correct? ger korrekta svar för alla möjliga indata (antal och lista). Bifoga ett par körexempel.

Uppgift 6 ----------------------------------------------------------------------Definiera funktionen enumerate som returnerar en lista med tal från from till to med avstånd step, inklusive gränserna. Indata är alltid heltal. (enumerate (enumerate (enumerate (enumerate

1 6 1) −→ (1 2 3 4 5 6) 1 20 5) −→ (1 6 11 16) -10 -2 2) −→ (-10 -8 -6 -4 -2) 5 1 19) −→ () 4

Uppgift 7 ----------------------------------------------------------------------Att kunna vända en lista är en rätt grundläggande uppgift2 . Här ska vi implementera funktioner som skapar en kopia av listan, men i omvänd ordning.

Del 7A Implementera reverse-order-rek som en linjärt rekursiv funktion som tar en lista, och ger en version av listan i omvänd ordning. Ledning: det kan underlätta om ni implementerar en procedur som fungerar ungefär som append. Se kursboken sid 102-103. (reverse-order-rek ’(1 2 3 4)) −→ ’(4 3 2 1) (reverse-order-rek ’((1 2) (3 4))) −→ ’((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).

Del 7B Ni ska även implementera reverse-order-iter. Den ska ha samma funktionalitet som reverse-order-rek, men vara iterativt rekursiv. Ni kan testa era implementationer genom att jämföra med reverse. (reverse-order-iter ’(1 2 3 4)) −→ ’(4 3 2 1) Ni behöver inte skriva ett predikat som testar dessa funktioner.

Uppgift 8 ----------------------------------------------------------------------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 (”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 16 25)) −→ (1 2 3 4 5) I era testfall kan ni jämföra med Rackets inbyggda map. 2

Och övning i att hantera parstrukturer. I matematisk mening ger man bilden av listan under dubblerings-funktionen. Ordet map är just matematikens avbildning. 3

5

Uppgift 9 ----------------------------------------------------------------------Att en lista är sorterad är ofta avgörande för att kunna göra effektiva sökningar4 , 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ättningssortering5 . Ni behöver bara hantera listor som innehåller siffror. Ni kan jämföra utdata med (sort listan