Gjennomgåelse av eksamensoppgaven i HUMIT2710 fra våren 2004

Transkript

1 Gjennomgåelse av eksamensoppgaven i HUMIT2710 fra våren 2004 Oppgave 1 For å komme nærmere kvadratroten til et tall fra en foreløpig tilnærming y, kan vi bruke formelen (y + /y)/2. Dette gir grunnlag for følgende Scheme program. (define (kvadratrot ) (kvadratrot-tilnærming 1.0 )) (define (kvadratrot-tilnærming y ) (if (nær-nok-kvadratrot? y ) y (kvadratrot-tilnærming (nærmere-kvadratrot y ) ))) (a) For å komme nærmere kuberoten (tredjeroten) til et tall fra en foreløpig tilnærming y, kan vi bruke formelen (2y + /y 2 )/3. Skriv prosedyrene (nær-nok-kuberot? y ), (nærmere-kuberot y ) og (kube ) tilsvarende (nær-nok-kvadratrot? y ), (nærmere-kvadratrot y ) og (kvadrat ). (define (nær-nok-kvadratrot? y ) (< (abs (- (kvadrat y) )) 0.001)) (define (nærmere-kvadratrot y ) (/ ( + y (/ y)) 2)) (define (kvadrat ) (* )) (a) (define (naer-nok-kuberot? y ) (< (abs (- (kube y) )) 0.001)) (define (naermere-kuberot y ) (/ (+ (* y 2) (/ (kvadrat y))) 3)) (define (kube ) (* )) (b) Skriv om prosedyren kvadratrot-tilnærming til en generell prosedyre tilnærming som tar et toarguments-predikat nær-nok? og en to-arguments-prosedyre nærmere som argumenter i tillegg til argumentene og y. Skriv så en prosedyre kuberot som kaller tilnærming med passende argumenter fra (a). (c) Skriv om prosedyren kuberot fra (b) slik at den kaller tilnærming med lambda-uttrykk i stedet for ferdig definerte prosedyrer. (b) (define (tilnaerming y naer-nok? naermere) (if (naer-nok? y ) y (tilnaerming (naermere y ) naer-nok? naermere))) (define (kuberot ) (tilnaerming 1.0 naer-nok-kuberot? naermere-kuberot)) (c) (define (kuberot ) (tilnaerming 1.0 (lambda (y ) (< (abs (- (kube y) )) 0.001)) (lambda (y ) (/ (+ (* y 2) (/ (kvadrat y))) 3))))

2 (d) Gitt følgende definisjon og kalleksempler, der prosedyren tilnærming er fra punkt (b): (define (listesøk liste) (tilnærming liste <??> <??>)) (listesøk 'c '(a b c d)) (c d) (listesøk 'e '(a b c d)) () Fyll ut de manglende delene med passende lambda-uttrykk. Poenget her er at problemet: finn del-listen som begynner med i listen liste, er det samme som problemet: finn kvadratroten av med utgangspunkt i gjettingen y. Vi starter med den gjettingen at ligger først i liste. (define (listesøk liste) (tilnaerming liste (lambda (liste ) ; Er vi nær nok? Eller (or (null? liste) (eq? (car liste)))) ; fant vi ingenting? (lambda (liste ) (cdr liste)))) ; Prøv å komme nærmere. Oppgave 2 Vi skal se på addisjon, subtraksjon, multiplikasjon og divisjon av positive heltall. Som basis for disse operasjonene tar vi følgende prosedyrer for gitt: (define (zero? ) ) ; Returnerer #t eller #f avhengig av om er mindre enn noe ; annet positivt heltall, eller ikke. (define (inc ) ) ; Returnerer det nærmeste heltallet til som er større enn. (define (dec ) ) ; Returnerer det nærmeste heltallet til som er mindre enn, ; eller, om det ikke finnes noe slikt tall. Ved hjelp av disse skal vi implementere følgende prosedyrer: (define (add y) ) ; Returnerer summen av og y. (define (sub y) ) ; Returnerer den positive differansen mellom og y, eller det ; minste mulige heltallet, hvis en slik differanse ikke finnes. (define (mul y) ) ; Returnerer produktet av og y. (define (div y) ) ; Returnerer den hele kvotienten mellom og y. I det følgende betyr 'strengt rekursiv' og 'halerekursiv', hhv. 'som gir opphav til en rekursiv prosess ' og 'som gir opphav til en iterative prosess' (a) Adderingen i add skal utføres ved at add kun kaller basisprosedyrene og seg selv. (b) Skriv en halerekursiv versjon av prosedyren add, uten å bruke noen hjelpeprosedyre. Skriv en strengt rekursiv versjon av prosedyren add, uten å bruke noen hjelpeprosedyre. rekursiv add y sier oss hvor mange ganger utgangspunktet må inkrementeres (define (add y) (if (zero? y) ; Har ikke mer å legge til ; er den samme som ved det initielle kallet (inc (add (dec y))))) ; dekrementér y på vei inn i og ; inkrementér på vei ut av rekursjonen iterativ add y sier oss hvor mange ganger utgangspunktet må inkrementeres (define (add y) (if (zero? y) ; har ikke mer å legge til ; er ferdig inkrementert (add (inc ) (dec y)))) ; Dekrementér y og inkrementér ; i hver iterasjonen

3 (c) Subtraheringen i sub skal utføres på tilsvarende måte som adderingen i add, hvilket bl.a. utelukker bruken av noen sammenligningsoperator. Skriv en halerekursiv versjon av prosedyren sub, uten å bruke noen hjelpeprosedyre. (d) Ved beregningen av produktet i mul kan det, i tillegg til basisprosedyrene, være greit å benytte prosedyren add og sub hhv. i allmentilfellet og i basistilfellet ved rekursjonen. (Ettertanke: Ingen grunn til å bruke sub. Basistilfellet er (zero? y), og vi kan da returnere y.) Skriv en strengt rekursiv versjon av prosedyren mul, uten å bruke noen hjelpeprosedyre.. rekursiv sub y sier oss hvor mange ganger utgangspunktet må dekrementeres (define (sub y) (if (or (zero? y) ; Har ikke mer å trekke fra (zero? )) ; Kan ikke gå under null (vi har ikke negative tall) (sub (dec ) (dec y)))) ; Dekrementér begge i hver iterasjon (define (mul y) (if (zero? y) ; skal ikke legge til flere ganger y ; må retunere variabelen y siden 0 ikke er definert (add (mul (dec y)) ))) ; legg enda en til resultatet, ; på vei ut av rekursjonen (e) En mulig strategi for å beregne heltallskvotienten i div, er å telle hvor mange ganger divisor y kan dekrementeres, samtidig som dividenden dekrementeres så langt ned som mulig. Med en slik strategi kan det være greit å bruke en hjelpeprosedyre. Skriv prosedyren div. Vil vi sikre oss mot null-divisjon, kan vi la divideringen utføres i en lokal prosedyre. (define (div y) (define (div ) <se under>) ; Vi kan la indre div skygger for yttre, siden yttre bare skal kalles utenfra. (if (zero? y) (error "div: division by zero!" y) (div ))) Resultatet, som telles opp fra 0, inkrementeres hver gang vi trekker fra y. (define (div y) (if (zero? (sub (inc ) y)) ; sub returnerer minimum zero. Se under angående (inc ). (sub ) ; tell opp fra 0 på vei ut av rekursjonen. Vi bruker (sub ) for å få 0. (inc (lokal-div (sub y) y)))) ; trekk y fra én gang til og tell hele deler på vei ut. Det kan virke nærliggende å la testen være (zero? sub y), men det ville ha gitt galt resultat, når divisjonen gikk opp. Inkrementeringen av i (zero? (sub (inc ) y)) sikrer rett resultat i alle tilfeller. (div 11 4) (div 12 4) runde (sub (inc ) y) = retur runde (sub (inc ) y) = retur (div 13 4) Denne divisjonen går opp. runde (sub (inc ) y) = retur I runde 3 ville (sub y) ha gitt 0, og vi ville ha stoppet én runde for tidlig

4 Oppgave 3 Vi skal representere mengder som uordnede lister med bare unike elementer. Til representasjonen regner vi følgende primitiver for par og lister (når en liste er et par der andre del er er et par eller den tomme listen). - Konstruktoren cons tar to argumenter og konstruerer et par av disse. - Selektoren car tar et par som argument og returnerer dettes første element. - Selektoren cdr tar et par som argument og returnerer dettes andre element. - Predikatet null? tar en liste som argument og returnerer #t hvis denne er den tomme listen. Den tomme listen angir vi slik: '(). I tillegg tar vi predikatet (medlem? obj liste) for gitt. Dette sjekker eventuelle atomære objekter og lister i liste og returnerer #t eller #f, avhengig av om obj ble funnet eller ikke. (Ettertanke: Her kunne det ha kanskje ha vært advart mot sammenblanding med standardprosedyren member, som i motsetning til medlem? er et semipredikat, men siden medlem? ikke skal implementeres, er det vel greit slik det står) (a) Skriv prosedyren (legg-til-mengde element mengde) som legger element til mengde og returnerer resultatmengden. Kalleksempler: (legg-til-mengde 3 '(1 5)) (3 1 5) (legg-til-mengde 3 '(3 1 5)) (3 1 5) (define (legg-til-mengde element mengde) (if (medlem? element mengde) mengde (cons element mengde))) Siden det nye elementet cons'es på mengden hadde navnet legg-første-i-mengde kanskje ha vært mer dekkende, særlig, skal vi se, med henblikk på på oppgave (e), så vi definerer følgende synonym: (define legg-først-i-mengde legg-til-mengde) (b) Skriv predikatet (mengde? liste), som sjekker om liste er en mengde, dvs. om den inneholder bare unike verdier. Kalleksempler: (mengde? '(3 1 5)) #t (mengde? '( )) #f (c) Skriv predikatet (delmengde? A B) som sjekker om A er en delmengde av B, dvs. om alle elementene i A finnes i B. Kalleksempler: (delmengde? '(1 5) '(3 1 5)) #t (delmengde? '(3 1 5) '(3 1 5)) #t (delmengde? '(3 5) '(7 1 5)) #f (b) (mengde? liste) Alternativ 1 Alternativ 2 (samme logikk som i 1, siden cond, and og or alle er definert ved if) (define (mengde? M) (define (mengde? M) (cond ((null? M)) (or (null? M) ((medlem? (car M) (cdr M)) #f) (and (not (medlem? (car M) (cdr M))) (else (mengde? (cdr M))))) (mengde? (cdr M))))) I alternativ 1 utnytter vi at en cond-clause tar ett eller flere uttrykk og returnerer resultatet av evalueringen av det siste. I begge alternativer er vi fornøyd hvis vi har kommet gjennom hele listen set, uten å finne noe element som har et identisk element etter seg i listen. (c) (delmengde? A B) Alternativ 1 Alternativ 2 (samme logikk som i 1, siden cond, and og or alle er definert ved if) (define (delmengde? A B) (define (delmengde? A B) (cond ((null? A)) (or (null? A) ((not (medlem? (car A) B)) #f) (and (medlem? (car A) B) (else (delmengde? (cdr A) B)))) (delmengde? (cdr A) B))))

5 (d) Skriv prosedyren (snitt A B) som returnerer snittet av mengdene A og B. Kalleksempler: (snitt '(1 5) '(3 7)) () (snitt '(3 7 5) '(7 1 5)) (7 5) (snitt '(5 3 1) '(3 1 5)) (5 3 1) (e) Potensmengden til en mengde er mengden av alle dens delmengder. F.eks. har mengden {1, 2, 3, 4} følgende potensmengde, bestånde av 2 4 = 16 mengder: {{}, {1}, {2}, {3}, {4}, {1, 2}, {1, 3}, {1, 4}, {2, 3}, {2, 4}, {3, 4}, {1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}, {1, 2, 3, 4}} Vi merker oss at den tomme mengden er med her. I algoritmen for å generer potensmengden til en mengde kan det imidlertid være forenklende å utelate den tomme mengden fra resultet. (Ettertanke: Dette tipset er nokså tøvete og bare relevant i noen dårlige løsninger). Skriv prosedyren (potensmengde M) som genererer potensmengden til M, med eller uten den tomme mengden. (d) (snitt A B) (rekursiv variant) (define (snitt A B) (cond ((or (null? A) (null? B)) '()) ((medlem? (car A) B) (cons (car A) (snitt (cdr A) B))) (else (snitt (cdr A) B)))) Hint: En mulig strategi er rekursivt å legge første element i løpende mengde til hver mengde i potensmengden til resten av løpende mengde, og så legge resulatet av alt dette sammen med potensmengden til resten av løpende mengde. Her kan det være greit med en hjelpeprosedyre, og i den vil du kunne dra nytte av punkt (a) (I det følgende har jeg brukt engelsk, for korthets skyld.) En hjelpeprosedyre må gi en ad hoc mapping. Generisk mapping Eks: {1, 2, 3, 4} potensmengden av {2, 3, 4} har de 8 mengdene {{}, {2}, {3}, {4}, {2, 3}, {2, 4}, {3, 4}, {2, 3, 4}} Hvis vi legger 1 først i hver av disse, får vi resten av potensmengden til {1, 2, 3, 4} {{1}, {1, 2}, {1, 3}, {1, 4}, {1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {1, 2, 3, 4}} NB! I den første løsningen følger vi ikke hintet om å bruke en hjelpeprosedyre, men bruker i stedet map, som tar seg av det vi er ute etter. (define (powerset set) (if (null? set) '(()) (let ((first-remaining (car set)) (powerset-of-rest (powerset (cdr set)))) (append powerset-of-rest (map (lambda (set) (cons first-remaining set)) powerset-of-rest))))) (define (prepend-every-set element sets) (define (map proc set) (if (null? sets) (if (null? set) '() '() (cons (cons (cons element (car sets)) (proc (car set) (prepend-every-set element (cdr sets))))) (map proc (cdr set))))) Dette gir følgende løsning (define (powerset set) (if (null? set) '(()) ; returner mengden med null-mengden (let ((powerset-of-rest (powerset (cdr set)))) (append powerset-of-rest (prepend-every-set (car set) powerset-of-rest)))))

6 Oppgave 4 Vi skal se på strømmer. Til representasjonene av strømmer hører følgende: - Spesialformen cons stream tar to argumenter og konstruerer et strømobjekt av disse i form av et par der første del er første argument ferdig evaluert og andre del er et løfte om evalueringen av andre argument. - Selektoren stream car tar et strømobjekt som argument og returnerer dets første del. - Selektoren stream cdr tar et strømobjekt som argument og fremtvinger evalueringen av dets andre del. - Predikatet stream null? tar et strømobjekt eller den tomme strømmen som argument og returnerer #t eller #f avhengig av om dette er den tomme strømmen eller ikke. - Den tomme strømmen stream nil ('()). I tillegg tar vi følgende prosedyrer for gitt: - Prosedyren (stream filter p s) som returnerer strømmen med de elementer i strømmen s som tilfredstiller predikatet p. - Prosedyren (finitt-strøm->liste s) som konverterer den endelige strømmen s til en liste. (a) Definer prosedyren (heltall-fra n) som returnerer den uendelige strømmen av heltall fra og med n. (define (heltall-fra n) (cons-stream n (heltall-fra (+ n 1)))) (b) Definer prosedyren (uten felles faktorer s) der s er en strøm med heltall. Prosedyren skal returnerer strømmen der første element er første element i s, og der ingen av de etterfølgende elementene er delelig med første element. Prosedyren skal dessuten være rekursiv slik at ingen av elementene i resultatstrømmen har felles faktorer. Du kan ta for gitt predikatet (delelig? y) som returnerer #t eller #f avhengig av om heltallet er delelig med heltallet y, eller ikke (b) (define (uten-felles-faktorer tallstrøm) (cons-stream (stream-car tallstrøm) (uten-felles-faktorer (stream-filter (lambda () (not (delelig? (stream-car tallstrøm)))) (stream-cdr tallstrøm))))) (c) Primtallsfaktorene til et heltall er de primtallene tallet er et produkt av. F.eks. har tallet 84 primtallsfaktorene 2, 2, 3 og 7. Faktoriseringen kan gjøres ved hjelp av primtallsstrømmen, og arbeidsmengden vil da bl.a. være bestemt av hvor mange primtall vi må sjekke før alle faktorene er identifisert. (At arbeidsmengden også er bestemt av hvor mange ganger hver enkelt primtallsfaktor forekommer i det aktuelle tallet, ser vi bort fra.) Har faktoriseringsalgoritmen lineær vekst må vi for å faktorisere f.eks. tallet 35 sjekke de fire primtallen 2, 3, 5 og 7 (og vi må sjekke de samme fire tallene for å faktorisere bl.a. 7, 14, 21, 70 og ). Definer prosedyren (faktorer n) som returnerer den endelige strømmen av primtallsfaktorene i n. Prosedyren skal beregne de aktuelle faktorene vha. primtallsstrømmen, og den skal ha en lineært voksende arbeidsmengde. Du kan definere primtallsstrømmen ved å kombinere (a) og (b) og bruke en lokal hjelpeprosedyre for å mate den inn. Kalleksempler: (finitt-strøm->liste (faktorer 42)) (2 3 7) (finitt-strøm->liste (faktorer 360)) ( )

7 (define (faktorer n) (define (iter n primtall) (cond ((= n 1) stream-nil) ((delelig? n (car primtall)) (cons-stream (car primtall) ; Det kan være flere av denne (iter (/ n (car primtall)) primtall))) ; så vi holder på løpende ; primtall inntil videre. (else (iter n (stream-cdr primtall))))) ; Ingen primtallsfaktor (iter n (uten-felles-faktorer (heltall-fra 2)))) (d) Når vi beregner et talls faktorer vha. primtallsstrømmen er det mulig å redusere arbeidsmengden slik at vi for å faktoriserer f.eks. tallet 138 = kan nøye oss med å sjekke primtallene 2, 3 og 5. Definer en versjon av faktorer som har mindre enn linær vekst. Følgende er en tillemping av én av lærebokas algoritmer for generering av primtallsstrømmen (s 330). (define (faktorer n) (define (kvadrat n) (* n n)) (define (iter n primtall) (cond ((> (kvadrat (car primtall)) n) (cons-stream n stream-nil)) ((delelig? n (car primtall)) (cons-stream (car primtall) (iter (/ n (car primtall)) primtall))) (else (iter n (stream-cdr primtall))))) (iter n (uten-felles-faktorer (heltall-fra 2)))) F.eks. 138 / (2 3) = 23 og 23 < (e) Gjør kort rede for prinsippet for vekstreduksjonen fra (c) til (d). Ettertanke: Dette er ikke en god oppgave. Alle oppgaver bør dreie seg om koding. Vekstreduksjonen er tilnærmet radikal, dvs. om vi, for enkelhets skyld, antar at det finnes en slik at for alle heltallsintervaller av lengde y er antall primtall = lik y/, så er veksten redusert fra n/ til ( n)/. Vekstreduksjonen oppnås ved at faktoriseringen avsluttes når løpende primtall p k > n, hvilket vil si det samme som at p k > n / p k. Dermed kan det ikke finnes noe primtall større enn p k som deler n, og n må selv være et primtall. (f) Divisorene til et heltall er de tall som deler tallet. Regner vi med 1 og tallet selv, har f.eks. tallet 30 de åtte divisorene 1, 2, 3, 5, 6, 10, 15 og 30. Tallet 30 har primtallsfaktorene 2, 3 og 5, og vi merker oss at hver divisor, bortsett fra 1, enten er en av primtallsfaktorene eller et produkt av to eller flere av disse. Definer prosedyren (divisorer n) som returnerer listen med divisorene til n. Hint: Du vil her, i tillegg til prosedyren faktorer og finitt-strøm->liste, kunne ha nytte av prosedyren potensmengde i 3(e) (du må gjerne bruke prosedyren, selv om du ikke løste oppgaven)

8 (define (divisorer n) (map (lambda (subset) (apply * subset)) (potensmengde (finitt-stream->list (faktorer n))))) Merk at mengden av primtallsfaktorer er en multimengde der vi tillater flere elementer med same verdi. For eksempel har 12 faktoren (2 2 3) som med unike verdier gir potensmengden (() (2) (3) (2 3)) men som med multiset gir (() (3) (2) (2 3) (2) (2 3) (2 2) (2 2 3)). Dette gir divisorene ( ). Her må vi ha med både (2 2) og (2 2 3) for å få med 4 og 12. På den andre siden, skal divisormengden ikke være et multimengde, så det vi skulle ha fått er ( ). Dette forventes det ikke at man skal ta hensyn til, men gjør man det, gir det et ekstra positivt inntrykk. En prosedyre for å fjerne duplikater fra et multiset kunne ha sett slik ut: (define (remove-duplikates set) (cond ((null? set) '()) ((member (car set) (cdr set)) (remove-duplikates (cdr set))) (else (cons (car set) (remove-duplikates (cdr set))))))