INF Gruppelærerenes side

Størrelse: px
Begynne med side:

Download "INF Gruppelærerenes side"

Transkript

1 INF Gruppelærerenes side Lars Tveito March 3, 2015 Contents Oversikt Dette siden er ment som et hjelpemiddel for oppgaveløsning, og inneholder også litt informasjon om gruppetimene. Det er skrevet løsningsforslag for mange oppgaver, og målet er at alle oppgaver skal ha løsningsforslag før den aktuelle uken. Den er også tilgjengelig som PDF og ren tekst (UTF-8). Det sagt oppfordrer vi på det sterkeste å løse oppgavene på egenhånd før man titter på løsningsforslaget. Det er verdt å nevne at det finnes veldig mange løsningsforslag på SICP-oppgaver på nettet, og disse kan være verdt å sjekke ut dersom man ønsker å se andre løsninger på oppgavene. Dersom dere skulle finne feil i løsningsforslagene (om det er skrivefeil, tenkefeil eller en lite god implementasjon) må dere gjerne gi beskjed på inf2810- hjelp@ifi.uio.no! Først en liten oppsummering av semesterplanen som viser hvilke grupper som går, hva som foreleses og hvilke oppgaver dere er anbefalt å løse. 1

2 Uke Gruppe Obliger Forelesning 4 Introduksjon til kurset og Scheme. 5 1, 2, 3, 4 Rekursjon, iterasjon og blokkstruktur. 6 1, 2, 3, 4 1a Lister og listerekursjon. 7 1, 2, 3, 4 Høyereordens prosedyrer og anonyme prosedyrer. 8 1, 2, 3, 4 Lokale variabler. Dataabstraksjon. 9 1, 2, 3, 4 1b Huffmankoding. 10 1, 2, 3, 4 Mengder. Lokal tilstand og destruktive operasjoner. 11 1, 2, 3, 4 Omgivelsesmodellen 12 1, 2, 3, 4 2a Destruktive (liste)operasjoner. Køer. 13 1, 2, 3, 4 Tabeller. 14 Påske 15 2, 3 2b Strømmer. 16 1, 2, 3, 4 Strømmer. 17 2, 3 Metasirkulær evaluator. 18 1, 2, 3, 4 3a Metasirkulær evaluator, del 2 (lazy evaluation) 19 1, 2, 4 Repetisjon, Eksamensforberedelse. 20 1, 2, 3, 4 3b Forelesning? 21 1, 2, 3, 4 Gruppetimer med eksamensforberedelse. 22 1, 2, 3, 4 Gruppetimer med eksamensforberedelse. 23 1?, 2?, 3?, 4? Eksamen 5. juni! Det er på semestersiden dere vil finne all praktisk informasjon, og eventuelle endringer er ikke garantert å komme med her. Med andre ord, ikke bruk dette som en erstatning for timeplanen. Gruppeundervisningen Stort sett vil det være én time med tavleundervisning i plenum, og én time til selvstendig arbeid der man kan få hjelp med kodingen. I uker rett før en innelevering vil det nok brukes mindre tid på tavleundervisningen, med mindre det er ønske om noe annet. Det er lov å spørre om hva som helst, men man kan ikke forvente å få svar på alle spørsmål om obligene. Istedet for å spørre om akkurat det som spørres om i obligene, prøv heller å finne et relatert problem som vil hjelpe løse oppgaven. Eller så kan man prøve å abstrahere spørsmålet, slik at man blir forklart et konsept fremfor hvordan man skal løse oppgaven. Et siste tips er å bruke tid på å virkelig forstå problemet man jobber med før man prøver å løse det. 2

3 Resten av siden inneholder en oversikt over aktiviteten på gruppetimene for hver uke, samt ukesoppgavene (med løsningsforslag) man kan arbeide med. (Man står selvfølgelig fri til å løse andre oppgaver enn de som er anbefalt.) Uke 5 Første gruppetime skal brukes til å få en liten introduksjon til Scheme-koding, der det vil legges vekt på verktøyene som brukes. På tre av gruppetimene vil det bli brukt DrRacket, som er det anbefalte verktøyet for INF2810. På Lars sin gruppetime (gruppe 2, onsdag kl ) vil det gås gjennom Emacs i stedet. Kort oppsummert er DrRacket enklere å komme igang med, og flott for vårt kurs, men hvis man har erfaring med Emacs fra før, eller er interessert i ha et verktøy som kan håndtere andre språk kan man heller bruke Emacs. Dersom man er usikker på hva man skal velge kan man selvfølgelig komme på flere gruppetimer. Mer informasjon om Emacs i INF2810 ligger her. En stor forskjell på Scheme og Java (som vi antar de fleste har kjennskap til) er at Scheme er et interpretert språk, mens Java er et kompilert språk. I et interpretert språk startes det et program som kan tolke språket; vi kan få programmet til å tolke uttrykkene vi skriver og det svarer med hva uttrykket evalueres til. Dette er anderledes fra et kompilert språk, der man istedet har et program som leser hele kildekoden og spytter ut noe som er kjørbart. De to fremgangsmåtene har hver sine fordeler og ulemper. En generell oppfatning er at interpreterte språk er raskere å utvikle, mens kompilerte språk kjørerer raskere og tryggere. Gjerne reflekter over hvorfor det er slik; dette kan gjerne diskuteres i gruppetimen. Det vi skal lære er å bruke det at språket er interpretert til vår fordel. Vi ønsker ikke å kjøre hele programmet under utvikling, fordi et hvert velskrevet program er delt opp i mange små moduler (i Scheme vil modulene bestå av prosedyrer, mens i Java vil det typisk bestå av klasser, metoder og grensesnitt). En språktolker har et REPL, som står for read-eval-print-loop. Vi kan bruke den på følgende måte: repl> (+ 1 1) => 2 3

4 repl> Det som skjer her er at repl> (som skal være en prompt), venter til du trykker på RET (enter), etter det evaluerer den uttrykket (det vil si den finner resultatet av kallet (+ 1 1)) printer ut det uttrykket ble evaluert til, og vil etter dette vente på et nytt uttrykk. Det er lurt å bruke litt tid på å bli kjent med REPL et, og vende seg til å utvikle et program i små biter, siden dette lar deg i større grad konsentrere deg om en ting ad gangen. Hovedpoenget her er ikke at man bruker REPL et, men at man blir vandt med tanken om at man kun trenger å kjøre en liten del av programmet under utvikling. I gruppetimen vil dere få eksempler på hvordan vi utvikler interaktivt i et interpretert språk. Ekstrastoff For å få bedre innsikt i hvordan et REPL fungerer, kan vi implementere en selv. (define (repl) (display "repl> ") (display (eval (read) (interaction-environment))) (newline) (repl)) Vi definerer repl som en prosedyre som først skriver ut prompt en vår, der vi bruker display til å skrive ut. I neste linje skjer magien; display skriver bare ut, eval evaluerer uttrykket i en gitt omgivelse og read leser fra tastaturet. Merk hvordan kallene er nøstet, hadde vi skrevet dette i Java-aktig syntaks kunne kallet sett slik ut: println(eval(read(), interaction-environment())). Til slutt skriver vi ut et linjeskift, og kaller på repl. Siden repl er den prosedyren vi er i ferd med å definere, betyr dette at det er et rekursivt kall, som gir oss loop en vi ønsker. Kallet på interaction-environment i seg selv er ikke interessant for pensum, men omgivelser generelt er det, som vi vil vende tilbake til i uke 10. 4

5 Uke 6 Denne uken jobber vi med hvordan Scheme evaluerer kode, og vi skal se på hva som skiller special forms fra vanlige prosedyrer. Vi skal jobbe med rekusjon, og hvordan vi uttrykker iterative prosesser ved hjelp av rekursjon (kalt hale-rekursjon). Exercise 1.4 Observe that our model of evaluation allows for combinations whose operators are compound expressions. Use this observation to describe the behavior of the following procedure: (define (a-plus-abs-b a b) ((if (> b 0) + -) a b)) Dersom b er positiv evalueres if-uttrykket til +, så vi vil legge sammen a og b. Dersom b ikke er positivt vil vi trekke b fra a, siden if-uttrykket vil evalueres til -. Prosedyren vil altså legge sammen a med absoluttverdien til b. Exercise 1.5 Ben Bitdiddle has invented a test to determine whether the interpreter he is faced with is using applicative-order evaluation or normal-order evaluation. He defines the following two procedures: (define (p) (p)) (define (test x y) (if (= x 0) 0 y)) Then he evaluates the expression (test 0 (p)) 5

6 What behavior will Ben observe with an interpreter that uses applicativeorder evaluation? What behavior will he observe with an interpreter that uses normal-order evaluation? Explain your answer. (Assume that the evaluation rule for the special form if is the same whether the interpreter is using normal or applicative order: The predicate expression is evaluated first, and the result determines whether to evaluate the consequent or the alternative expression.) Applicative-order vil si at alle argumenter vil evalueres før de sendes til prosedyren. Dermed vil kallet på (test 0 (p)) forårsake at evalueringen ikke vil terminere, siden p vil kalle seg selv rekursivt. Normal-order vil si at argumentene først evalueres når vi trenger de. Vi behøver ikke å vite hva y er for å avgjøre om vi skal returnere 0 eller y, så da vil heller aldri y (som representerer et kall på (p)) evalueres. Testen vil evalueres til 0. Exercise 1.6 Alyssa P. Hacker doesn t see why if needs to be provided as a special form. "Why can t I just define it as an ordinary procedure in terms of cond?" she asks. Alyssa s friend Eva Lu Ator claims this can indeed be done, and she defines a new version of if: (define (new-if predicate then-clause else-clause) (cond (predicate then-clause) (else else-clause))) Eva demonstrates the program for Alyssa: (new-if (= 2 3) 0 5) 5 (new-if (= 1 1) 0 5) 0 Delighted, Alyssa uses new-if to rewrite the square-root program: 6

7 (define (sqrt-iter guess x) (new-if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))) What happens when Alyssa attempts to use this to compute square roots? Explain. Siden new-if er en prosedyre vil alle argumentene til new-if evalueres. sqrt-iter vil dermed kalles uavhengig av om good-enough? returnerer sant eller usant. Derfor vil ethvert kall på prosedyren forårsake et rekursivt kall, og den vil derfor ikke terminere. Exercise 1.9 Each of the following two procedures defines a method for adding two positive integers in terms of the procedures inc, which increments its argument by 1, and dec, which decrements its argument by 1. (define (+ a b) (if (= a 0) b (inc (+ (dec a) b)))) (define (+ a b) (if (= a 0) b (+ (dec a) (inc b)))) Using the substitution model, illustrate the process generated by each procedure in evaluating (+ 4 5). Are these processes iterative or recursive? Den første versjonen av + gir opphav til en rekursiv prosess: (+ 4 5) (inc (+ 3 5)) 7

8 (inc (inc (+ 2 5))) (inc (inc (inc (+ 1 5)))) (inc (inc (inc (inc (+ 0 5))))) (inc (inc (inc (inc 5)))) (inc (inc (inc 6))) (inc (inc 7)) (inc 8) 9 Den andre versjonen av + gir opphav til en iterativ prosess: (+ 4 5) (+ (dec 4) (inc 5)) (+ (dec 3) (inc 6)) (+ (dec 2) (inc 7)) (+ (dec 1) (inc 8)) (+ 0 (inc 8)) 9 Uke 7 I første halvdel av ukens gruppetime blir det gjennomgang av utvalgte oppgaver fra innlevering 1a. I uke 6 ble det gjennomgått lister, høyereordens prosedyrer og lambda-uttrykk på forelesning. Vi skal se på hvordan vi kan implementere quicksort i Scheme, der vi må anvende verktøyene vi ble kjent med i uke 6. Ved ønske kan det også gjennomgås noen av de anbefalte oppgavene fra SICP under. Quicksort Quicksort er en effektiv sorteringsalgoritme som kan representeres i Scheme på en svært elegant måte. Skrive en prosedyre quicksort som tar en (potensielt) uordnet liste lst som input, og skal returnere en ordnet liste som inneholder nøyaktig de samme elementene som lst. Dere kan ta utgangspunkt i denne beskrivelsen av algoritmen: Velg et vilkårlig element x fra lst. 8

9 Anvend quicksort på alle elementene, bortsett fra x, i lst som er mindre eller lik x. Anvend quicksort på alle elementene, bortsett fra x, i lst som er større enn x. Slå sammen de to resulterende listene med x i midten. Dere trenger bare ta høyde for tall. Ressoner kort over kjøretiden til algoritmen. Append Vi må bruke append, som ikke er dekket på forelesning ennå, så den fortjener en forklaring. For å slå sammen lista kan vi bruke append, som tar et vilkårlig antall lister som argumenter, og returnerer en liste som inneholder alle elementene, fra alle listene som var gitt som input. Eksempler på bruk: (append '(1 2) '(3 4)) ; => ( ) (append '(1 2) '(3 (4 5)) '(2)) ; => (1 2 3 (4 5) 2) (append) ; => () Vi kan også implementere append, men merk at det er stoff ikke skal dekkes før neste forelesning. Først en variant som kun kan kombinere to lister. (define (append lst1 lst2) (if (null? lst1) lst2 (cons (car lst1) (append (cdr lst1) lst2)))) Vi kan videre generalisere append til å ta et vilkårlig antall argumenter; dette er stoff som først vil bli gjennomgått på forelesning i uke 10, så dere kan overse det inntil videre. (define (append. lists) (cond ((null? lists) '()) ((null? (car lists)) (apply append (cdr lists))) (else (cons (caar lists) (apply append (cdar lists) (cdr lists)))))) 9

10 Basistilfellet i algoritmen er når vi lst garantert er sortert; dette er når det er ett eller færre elementer i lst, da vil vi bare returnere lst. For enkelhets skyld vil vi la basissteget være når lst er den tomme lista. For å kunne samle opp alle elementer som er større/mindre enn x vil vi benytte oss av filter. La oss implementere den for å ha den friskt i minne. (define (filter pred lst) (cond ((null? lst) '()) ((pred (car lst)) (cons (car lst) (filter pred (cdr lst)))) (else (filter pred (cdr lst))))) Vi skal velge et vilkårlig element, dette kunne vi gjort ved å trekke ut et tilfeldig element, men dette virker unødvendig komplisert. La oss heller alltid velge det første elementet i lista (det spiller jo ingen rolle hvilket element vi velger, siden vi antar at lista er uordnet). Vi ønsker å gi en anonym prosedyre til filter, som sammenligner et tall x med det første elementet i lst. Lista vi ønsker å benytte filter på er alle elementene i lst som ikke inneholder det første elementet, altså (cdr lst). Her er alt satt sammen: (define (quicksort lst) (if (null? lst) lst (append (quicksort (filter (lambda (x) (<= x (car lst))) (cdr lst))) (list (car lst)) (quicksort (filter (lambda (x) (> x (car lst))) (cdr lst)))))) Hvert rekursive kall gjøres i snitt på en liste som er halvparten så stor som den vi fikk som input, det tilsier at vi får log 2 n rekursive kall. For hvert rekursive kall gjøres det to lineære operasjoner (nemlig kallet på filter), som gir 2n. Dette gir oss en kompleksitet på O(n log 2 n). 10

11 Insertion sort Som en ekstra utfordring kan dere implementere insertion sort, som går ut på at man legger alle elementene inn i en ny liste i sortert rekkefølge. Denne er mindre effektiv enn quicksort for store datamengder, men fungerer bra på små datasett, og er forholdsvis lett å implementere. Det kan være lurt å starte med å skrive en prosedyre tar inn et element og en liste, som er antatt å være sortert, og legger elementet inn i sortert rekkefølge. Vi vil benytte oss av reduce i denne implementasjonen av insertion-sort, så vi implementerer den som repetisjon. (define (reduce proc init lst) (if (null? lst) init (proc (car lst) (reduce proc init (cdr lst))))) add-sorted legger til et element på riktig sted, under antagelsen at lista som er gitt som argument er ordnet. (define (add-sorted x lst) (cond ((null? lst) (list x)) ((<= x (car lst)) (cons x lst)) (else (cons (car lst) (add-sorted x (cdr lst)))))) For å implementere insertion-sort trenger vi bare løpe over lista, og plassere hvert element i ordnet rekkefølge; dette kan vi gjøre med reduce. (define (insertion-sort lst) (reduce add-sorted '() lst)) Exercise 2.17 Define a procedure last-pair that returns the list that contains only the last element of a given (nonempty) list: (last-pair (list )) (34) 11

12 Vi må rekursere helt til cdr til listen er den tomme lista: (define (last-pair lst) (if (null? (cdr lst)) lst (last-pair (cdr lst)))) Dersom vi ikke vil ha med antagelsen om at lista er ikke-tom kan vi legge til en test på om lista er tom, og i så fall returnere den tomme lista. (define (last-pair lst) (if (and (not (null? lst)) (null? (cdr lst))) lst (last-pair (cdr lst)))) Exercise 2.21 The procedure square-list takes a list of numbers as argument and returns a list of the squares of those numbers. (square-list (list )) ( ) Here are two different definitions of square-list. Complete both of them by filling in the missing expressions: (define (square-list items) (if (null? items) nil (cons <??> <??>))) (define (square-list items) (map <??> <??>)) Vi definerer først square, siden denne ikke nødvendigvis er definert fra før. (define (square x) (* x x)) 12

13 (define (square-list items) (if (null? items) '() (cons (square (car items)) (square-list (cdr items))))) (define (square-list items) (map square items)) Exercise 2.22 Louis Reasoner tries to rewrite the first square-list procedure of exercise 2.21 so that it evolves an iterative process: (define (square-list items) (define (iter things answer) (if (null? things) answer (iter (cdr things) (cons (square (car things)) answer)))) (iter items nil)) Unfortunately, defining square-list this way produces the answer list in the reverse order of the one desired. Why? Louis then tries to fix his bug by interchanging the arguments to cons: (define (square-list items) (define (iter things answer) (if (null? things) answer (iter (cdr things) (cons answer (square (car things)))))) (iter items nil)) This doesn t work either. Explain. 13

14 I den halerekursive implementasjonen vil vi bygge en liste iterativt ved å legge til resultatet av (square (car things)) i begynnelsen av lista. Vi kan se nøyere på evalueringsprosessen: (square-list (list )) (square-list ( )) (iter ( ) ()) (iter (2 3 4) (1)) (iter (3 4) (4 1)) (iter (4) (9 4 1)) (iter () ( )) ( ) Når vi bygger opp en liste iterativt vil alltid det som legges inn først ende opp sist, siden vi jobber med en først-inn-sist-ut liste. Den har konstant tid på å legge inn elementer i begynnelsen, men lineær tid for å legge inn på slutten. Dersom rekkefølgen på resultatet spiller noen rolle (som den ofte gjør) er det vanlig å reversere resultatet i basistilfellet av prosedyren. Den andre varianten der argumentene til cons snus gir feil resultat, siden den returnerer ikke en liste! En liste er den tomme lista () eller et par der cdr er en liste. Det vi legger i cdr av lista er resultatet av (square (car things)), som ikke er en liste. (square-list (list )) (iter ( ) ()) (iter (2 3 4) ((). 1)) (iter (3 4) (((). 1). 4)) (iter (4) ((((). 1). 4). 9)) (iter () (((((). 1). 4). 9). 16)) (((((). 1). 4). 9). 16) Exercise 2.23 The procedure for-each is similar to map. It takes as arguments a procedure and a list of elements. However, rather than forming a list of the results, for-each just applies the procedure to each of the elements in turn, from left to right. The values returned by applying the procedure to the elements are 14

15 not used at all for-each is used with procedures that perform an action, such as printing. For example, (for-each (lambda (x) (newline) (display x)) (list )) The value returned by the call to for-each (not illustrated above) can be something arbitrary, such as true. Give an implementation of for-each. Her skal vi kun anvende prosedyren på hvert element i lista, og ignorere returverdiene. (define (for-each proc lst) (cond ((null? lst) 'ok) (else (proc (car lst)) (for-each proc (cdr lst))))) Her kunne vi brukt if istedet, men da måtte vi omsluttet else-grenen med begin, siden if forventer nøyaktig tre argumenter. I cond er hver gren representert som en liste, der første i lista avgjør om resten av lista skal evalueres, og der resten av lista kan være vilkårlig lang, som betyr at begin er implisitt i cond. Exercise 2.53 What would the interpreter print in response to evaluating each of the following expressions? (list 'a 'b 'c) (list (list 'george)) (cdr '((x1 x2) (y1 y2))) (cadr '((x1 x2) (y1 y2))) (pair? (car '(a short list))) (memq 'red '((red shoes) (blue socks))) (memq 'red '(red shoes blue socks)) 15

16 (list 'a 'b 'c) ; (a b c) (list (list 'george)) ; ((george)) (cdr '((x1 x2) (y1 y2))) ; ((y1 y2)) (cadr '((x1 x2) (y1 y2))) ; (y1 y2) (pair? (car '(a short list))) ; #f (memq 'red '((red shoes) (blue socks))) ; #f (memq 'red '(red shoes blue socks)) ; (red shoes blue socks) Exercise 2.54 Two lists are said to be equal? if they contain equal elements arranged in the same order. For example, (equal? '(this is a list) '(this is a list)) is true, but (equal? '(this is a list) '(this (is a) list)) is false. To be more precise, we can define equal? recursively in terms of the basic eq? equality of symbols by saying that a and b are equal? if they are both symbols and the symbols are eq?, or if they are both lists such that (car a) is equal? to (car b) and (cdr a) is equal? to (cdr b). Using this idea, implement equal? as a procedure. Siden både a og b kan være to forskjellige typer har vi i utgangspunktet fire forskjellige tilfeller vi må dekke. Merk at det ikke står noen ting i oppgaven om hva vi skal gjøre dersom a og b er av ulik type; dette er fordi at hvis de er av ulik type vil de heller ikke være like. Med denne observasjonen kan vi forenkle prosedyren til å uttrykke at a og b er like dersom (eq? a b) gir sann, eller så er de begge lister der (equal? (car a) (car b)) og (equal? (cdr a) (cdr b)) er begge sanne. (define (equal? a b) (or (eq? a b) (and (pair? a) (pair? b) 16

17 (equal? (car a) (car b)) (equal? (cdr a) (cdr b))))) Exercise 2.55 Eva Lu Ator types to the interpreter the expression (car ''abracadabra) To her surprise, the interpreter prints back quote. Explain. Først må vi merke oss at '-symbolet kun er syntaktisk sukker for å omslutte et parentesuttrykk med quote. For eksempel, er disse uttrykkene ekvivalente: (quote (1 2 3)) '(1 2 3). Dermed vet vi at ''abracadabra (quote (quote abracadabra)), og de evalueres til uttrykket (quote abracadabra), selv om dette vises som 'abracadabra. Når vi tar car av dette vil vi få ut det første i denne lista, som er quote. Uke 8 Koding av oppgavesett 1b. Exercise 1.30 (define (sum term a next b) (if (> a b) 0 (+ (term a) (sum term (next a) next b)))) The sum procedure above generates a linear recursion. The procedure can be rewritten so that the sum is performed iteratively. Show how to do this by filling in the missing expressions in the following definition: 17

18 (define (sum term a next b) (define (iter a result) (if <??> <??> (iter <??> <??>))) (iter <??> <??>)) Når vi "oversetter" en sann rekursiv prosedyre til en iterativ er det et par ting som går igjen. Det ene er at i basistilfellet ønsker vi å returnere et akkumulert resultat. Det vi ville returnert i basistilfellet i den rekursive prosedyren ønsker vi nå å gi som argument til den iterative prosedyren ved første kall. Så må vi få det rekursive kallet i hale-posisjon, og bygge på resultatet for hver iterasjon. (define (sum term a next b) (define (iter a result) (if (> a b) result (iter (next a) (+ result (term a))))) (iter a 0)) Exercise 1.31 a) The sum procedure is only the simplest of a vast number of similar abstractions that can be captured as higher-order procedures. Write an analogous procedure called product that returns the product of the values of a function at points over a given range. Show how to define factorial in terms of product. Also use product to compute approximations to using the formula π 4 = b) If your product procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process. 18

19 a) Vi tar utgangspunkt i den iterative løsningsen vår for sum. Det er to endringer som må på plass. Den ene er at vi må bruke * fremfor +, og det andre er at vi må endre basistilfellet fra 0 til 1. Dette er fordi 1 er identitetselementet for multiplikasjon. (define (product term a next b) (define (iter a result) (if (> a b) result (iter (next a) (* result (term a))))) (iter a 1)) Fakultetsfunksjonen kan regnes ut ved å gange 1 2 n, som kan uttrykkes med product. Her vil term være en funksjon som returnerer det den får som input (kjent som identitetsfunksjonen). Neste tall få vi ved å inkrementere. Her antar vi at begge er funksjonene definert, dersom de ikke er det bør disse være veldig greie å implementere selv. (define (factorial n) (product identity 1 inc n)) Vi har gitt en formel som konvergerer mot π 4, og vi skal bruke denne til å regne ut π. Først får vi formelen på en form som gjør det enklere å uttrykke den som en prosedyre. π 4 = = n + 2 n + 1, n=1 n + 1 n + 2, hvis n er partall hvis n er oddetall Nå vil term være en funksjon som returnerer n+2 n+1 n+1 hvis n er partall og n+2 hvis n er oddetall. Vi vil ta produktet fra 1 opp til en gitt grense gitt som argument, som vil avgjøre hvor nøyaktig approksimasjonen til π blir. Siden formelen vi har gitt gir π 4 må vi huske å gange med fire til slutt. (define (pi precision) (let ((term (lambda (n) (if (even? n) (/ (+ n 2) (+ n 1)) 19

20 (/ (+ n 1) (+ n 2)))))) (* (product term 1 inc precision) 4))) b) Vi implementerte product iterativt i a), så vi må skrive en rekursiv variant. Da kan ikke lengre det rekursive kallet være i haleposisjon, og vi vil kunne fjerne den indre prosedyren. Basistilfellet vil returnere det vi sendte til iter opprinnelig i den halerekursive varianten. (define (product term a next b) (if (> a b) 1 (* (term a) (product term (next a) next b)))) Exercise 1.32 a) Show that sum and product (exercise 1.31) are both special cases of a still more general notion called accumulate that combines a collection of terms, using some general accumulation function: (accumulate combiner null-value term a next b) Accumulate takes as arguments the same term and range specifications as sum and product, together with a combiner procedure (of two arguments) that specifies how the current term is to be combined with the accumulation of the preceding terms and a null-value that specifies what base value to use when the terms run out. Write accumulate and show how sum and product can both be defined as simple calls to accumulate. b) If your accumulate procedure generates a recursive process, write one that generates an iterative process. If it generates an iterative process, write one that generates a recursive process. a) For å implementere accumulate trenger vi bare abstrahere vekk det som er unikt for sum og product. Det eneste som skiller de to er hva som returneres i basistilfellet, og hvilken operasjon som brukes for å akkumulere (hhv. + og *). 20

21 (define (accumulate combiner null-value term a next b) (if (> a b) null-value (combiner (term a) (accumulate combiner null-value term (next a) next b)))) For å uttrykke sum trenger vi kun å supplere + som kombinatoren og 0 som basistilfelle. (define (sum term a next b) (accumulate + 0 term a next b)) På samme måte for product gir vi * som operator og 1 som basistilfelle. (define (product term a next b) (accumulate * 1 term a next b)) Exercise 1.34 Suppose we define the procedure (define (f g) (g 2)) Then we have (f square) 4 (f (lambda (z) (* z (+ z 1)))) 6 What happens if we (perversely) ask the interpreter to evaluate the combination (f f)? Explain. Her er f en funksjon som anvender prosedyren den får inn på argumentet 2. La tolkes som at uttrykket på venstre side reduseres til et uttrykket på høyere side i et eller flere steg. Da kan vi tolke kallene ovenfor slik: (f square) (square 2) 4 21

22 (f (lambda (z) (* z (+ z 1)))) ((lambda (z) (* z (+ z 1))) 2) (* 2 (+ 2 1)) 6. Dersom vi forsøker å anvende f på f vil den å anvende seg selv med argumentet 2. Da vil 2 bli anvendt som en prosedyre. Slik ser reduksjonen ut: (f f) (f 2) (2 2) Til slutt vil interpretereren anvende 2 på 2, og siden 2 ikke er en prosedyre får vi en feilmelding. Exercise 1.42 Let f and g be two one-argument functions. The composition f after g is defined to be the function x f(g(x)). Define a procedure compose that implements composition. For example, if inc is a procedure that adds 1 to its argument, ((compose square inc) 6) 49 Ofte vil vi sette sammen funksjoner; vi starter med å lage en prosedyre som returnerer en prosedyre som tar et argument og anvender det på g resultatet gir anvendes på f. (define (compose f g) (lambda (x) (f (g x)))) ((compose square inc) 6) Ekstraoppgave 1 Skriv en mer generalisert variant av compose som kan hete comp som tar en eller flere prosedyrer som argument. Prosedyrene som tas som argument skal kunne ta et vilkårlig antall argumenter. Først trenger vi en måte å anvende compose funksjonen på flere argumenter. Funksjonen reduce lar oss gjøre det; vi lar den ta to argumenter, en funksjon 22

23 f som tar to argumenter og en liste lst. Den lager nøstede uttrykk som (reduce + '( )) (+ 1 (+ 2 (+ 3 4))). (define (reduce f lst) (if (null? (cdr lst)) (car lst) (f (car lst) (reduce f (cdr lst))))) lambda-uttrykket må nå kunne ta inn et vilkårlig antall argumenter, så vi vil få inn en liste med argumenter. Dersom man istedet for å skrive en argument-liste, heller kun skriver et symbol, vil dette symbolet representere en liste med argumenter. Når vi nå skal anvende prosedyren på en liste av argumenter kan vi bruke apply, som anvender en funksjon på en liste med argumenter. Forskjellen på apply og reduce er at apply ikke nøster, men kun setter funksjonen i begynnelsen av lista. Samme eksempel som ovenfor: (apply + '( )) ( ). (define (compose f g) (lambda x (f (apply g x)))) Vi kan nå bruke reduce til å nøste sammen kallene på compose over en eller flere prosedyrer. Vi tar inn et eller flere argumenter til comp, som kan gjøres ved å ta inn et argument, og la resten av argumentene legges i en liste. (define (comp f. procs) (reduce compose (cons f procs))) Denne kan brukes til å sette samme funksjoner, som er veldig uttrykkskraftig. ((comp sum filter) even? (range 101)) 2550 Exercise 1.43 If f is a numerical function and n is a positive integer, then we can form the nth repeated application of f, which is defined to be the function whose value at x is f(f(... (f(x))... )). For example, if f is the function x x+1, then the nth repeated application of f is the function x x + n. If f is the operation of squaring a number, then the nth repeated application of f is the function that raises its argument to the 2nth power. Write a procedure 23

24 that takes as inputs a procedure that computes f and a positive integer n and returns the procedure that computes the nth repeated application of f. Your procedure should be able to be used as follows: ((repeated square 2) 5) 625 Hint: You may find it convenient to use compose from exercise Det vi skal gjøre er å rekursivt slå sammen f med seg selv n ganger. Vi har compose som kan brukes for sammenslåingen, så vi trenger kun bruke denne rekursivt. (define (repeated f n) (if (= 1 n) f (compose f (repeated f (- n 1))))) Ekstrastoff Dersom vi ønsker å bruke høyere-ordens prosedyrer for å uttrykke repeat kan vi gjøre det ved å bruke reduce og compose, eller ved å bruke apply og comp. (define (repeated f n) (reduce compose (make-list n f))) (define (repeated f n) (apply comp (make-list n f))) Exercise 1.44 The idea of smoothing a function is an important concept in signal processing. If f is a function and dx is some small number, then the smoothed version of f is the function whose value at a point x is the average of f(x dx), f(x), and f(x + dx). Write a procedure smooth that takes as input a procedure that computes f and returns a procedure that computes the smoothed f. It is sometimes valuable to repeatedly smooth a function (that is, smooth the smoothed function, and so on) to obtained the n-fold smoothed function. 24

25 Show how to generate the n-fold smoothed function of any given function using smooth and repeated from exercise Først kan vi definere et lite tall dx. (define dx ) Nå skal vi implementere prosedyren smooth, den skal ta inn en prosedyre f som tar inn et numerisk argument. (define (smooth f) (lambda (x) (/ (+ (f (- x dx)) (f x) (f (+ x dx))) 3))) For å kunne gjenta glattingen kan vi bruke repeated. Den lager uttrykk som (lambda (x) (smooth (smooth (smooth (f x))))). (define (n-fold-smooth f n) ((repeated smooth n) f)) Exercise 2.33 Fill in the missing expressions to complete the following definitions of some basic list-manipulation operations as accumulations: (define (map p sequence) (accumulate (lambda (x y) <??>) nil sequence)) (define (append seq1 seq2) (accumulate cons <??> <??>)) (define (length sequence) (accumulate <??> 0 sequence)) 25

26 Først må vi huske accumulate, istedet for å se i boka anbefales det å prøve å skrive den på egenhånd. Den ligner veldig på reduce som ble implementert tidligere. (define (accumulate comb init lst) (if (null? lst) init (comb (car lst) (accumulate comb init (cdr lst))))) map skal anvende en prosedyre på alle elementene i en liste og returnere en liste av resultatene. Da er cons limet vårt, og den tomme lista er initialverdien. Vi må huske å anvende prosedyren p på x, ellers ville vi bare returnert en kopi av lista. (define (map p sequence) (accumulate (lambda (x y) (cons (p x) y)) '() sequence)) Når vi skal sette sammen lister må vi få cdr til det siste paret i seq1 til å peke på seq2, på den måten får vi sammensetningen av to lister. Limet blir igjen cons, men basistilfellet blir å returnere seq2. En bemerkning her er at elementene i den første lista blir faktisk kopiert, men vi får bare en peker til den andre, så det vil altså være den samme lista vi sendte inn som input. (define (append seq1 seq2) (accumulate cons seq2 seq1)) Her virker det intuitivt å bruke inc, men her må vi ha en kombinator, og det den skal gjøre er å legge sammen 1 og y. Da kan vi lage en litt modifisert utgave av inc som tar inn to tall, og kun inkrementerer det andre tallet. (define (length sequence) (accumulate (lambda (x y) (+ 1 y)) 0 sequence)) Exercise 2.36 The procedure accumulate-n is similar to accumulate except that it takes as its third argument a sequence of sequences, which are all assumed to have the same number of elements. It applies the designated accumulation procedure to combine all the first elements of the sequences, all the second elements of the sequences, and so on, and returns a sequence of 26

27 the results. For instance, if s is a sequence containing four sequences, ((1 2 3) (4 5 6) (7 8 9) ( )), then the value of (accumulate-n + 0 s) should be the sequence ( ). Fill in the missing expressions in the following definition of accumulate-n: (define (accumulate-n op init seqs) (if (null? (car seqs)) nil (cons (accumulate op init <??>) (accumulate-n op init <??>)))) Det som skal akkumuleres over, er det første elementet fra hver liste i seqs. Når accumulate-n kalles rekursivt skal den få med resten fra hver liste i seqs. Det kan uttrykkes med (map car seqs) og (map cdr seqs). (define (accumulate-n op init seqs) (if (null? (car seqs)) '() (cons (accumulate op init (map car seqs)) (accumulate-n op init (map cdr seqs))))) Exercise 2.37 Suppose we represent vectors v = (v i ) as sequences of numbers, and matrices m = (m ij ) as sequences of vectors (the rows of the matrix). For example, the matrix is represented as the sequence (( ) ( ) ( )). With this representation, we can use sequence operations to concisely express the basic matrix and vector operations. These operations (which are described in any book on matrix algebra) are the following: 27

28 (dot-product v w) returns the sum i v iw i ; (matrix-*-vector m b) returns the vector t where t i = j m ijv j ; (matrix-*-matrix m n) returns the matrix p where p ij = k m ikn kj ; (transpose m) returns the matrix n where n ij = m ji ; We can define the dot product as (define (dot-product v w) (accumulate + 0 (map * v w))) Fill in the missing expressions in the following procedures for computing the other matrix operations. (The procedure accumulate-n is defined in exercise 2.36.) (define (matrix-*-vector m v) (map <??> m)) (define (transpose mat) (accumulate-n <??> <??> mat)) (define (matrix-*-matrix m n) (let ((cols (transpose n))) (map <??> m))) TODO (define (matrix-*-vector m v) (map (lambda (w) (dot-product v w)) m)) (define (transpose mat) (accumulate-n cons '() mat)) (define (matrix-*-matrix m n) (let ((cols (transpose n))) (map (lambda (v) (matrix-*-vector cols v)) m))) Exercise 2.38 The accumulate procedure is also known as fold-right, because it combines the first element of the sequence with the result of combining all the elements to the right. There is also a fold-left, which is similar to fold-right, except that it combines elements working in the opposite direction: 28

29 (define (fold-left op initial sequence) (define (iter result rest) (if (null? rest) result (iter (op result (car rest)) (cdr rest)))) (iter initial sequence)) What are the values of (fold-right / 1 (list 1 2 3)) (fold-left / 1 (list 1 2 3)) (fold-right list nil (list 1 2 3)) (fold-left list nil (list 1 2 3)) Give a property that op should satisfy to guarantee that fold-right and fold-left will produce the same values for any sequence. Det kan være nyttig å huske hvordan fold-right ser ut, eller enda bedre, implementere den selv. (define (fold-right op initial sequence) (if (null? sequence) initial (op (car sequence) (fold-right op initial (cdr sequence))))) For å forstå forskjellen mellom fold-right og fold-left kan en se på hva slags uttrykk de reduseres til (fold-right + 0 '( )) (+ 1 (+ 2 (+ 3 (+ 4 0)))) (fold-left + 0 '( )) (+ (+ (+ (+ 0 1) 2) 3) 4) Vi ser at de evaluerer i motsatt rekkefølge fra hverandre. Dette kommer av at fold-right er implementert rekursivt og fold-left er implementert iterativt. (fold-right / 1 (list 1 2 3)) 3/2 (fold-left / 1 (list 1 2 3)) 1/6 (fold-right list nil (list 1 2 3)) (1 (2 (3 ()))) (fold-left list nil (list 1 2 3)) (((() 1) 2) 3) 29

30 Dersom rekkefølgen på argumentene gitt til op ikke spiller noen rolle vil fold-right og fold-left alltid gi samme resultat. Dersom op har denne egenskapen sier vi at den er kommutativ. Exercise 2.39 Complete the following definitions of reverse (exercise 2.18) in terms of fold-right and fold-left from exercise 2.38: (define (reverse sequence) (fold-right (lambda (x y) <??>) nil sequence)) (define (reverse sequence) (fold-left (lambda (x y) <??>) nil sequence)) TODO (define (reverse sequence) (fold-right (lambda (x y) (append y (list x))) '() sequence)) (define (reverse sequence) (fold-left (lambda (x y) (cons y x)) '() sequence)) Uke 9 Det er siste uke før innlevering, så det blir hovedsakelig selvstendig arbeid med oblig 1b. Det er, som alltid, lov å komme med ønsker om ukesoppgaver som kan gjennomgås på tavlen. Exercise 2.2 Consider the problem of representing line segments in a plane. Each segment is represented as a pair of points: a starting point and an ending point. Define a constructor make-segment and selectors start-segment and end-segment that define the representation of segments in terms of points. Furthermore, a point can be represented as a pair of numbers: the x coordinate and the y coordinate. Accordingly, specify a constructor make-point 30

31 and selectors x-point and y-point that define this representation. Finally, using your selectors and constructors, define a procedure midpoint-segment that takes a line segment as argument and returns its midpoint (the point whose coordinates are the average of the coordinates of the endpoints). To try your procedures, you ll need a way to print points: (define (print-point p) (newline) (display "(") (display (x-point p)) (display ",") (display (y-point p)) (display ")")) En linje kan representeres som et par av punkter. Prosedyren cons gir oss et par, så vi kan representere en linje som en cons-celle som inneholder to punkter. For å aksessere paret kan vi bruke car for å hente ut det første elementet i paret, og cdr til å hente ut det andre. (define (make-segment p q) (cons p q)) (define (start-segment seg) (car seg)) (define (end-segment seg) (cdr seg)) Et punkt kan representeres som et par som inneholder to tall. Vi kan med andre ord representere punkter på samme måte som vi representerer linjer, men vi forventer tall i setedet for punkter. (define (make-point x y) (cons x y)) (define (x-point p) (car p)) 31

32 (define (y-point p) (cdr p)) Til slutt skal vi skrive en prosedyre som finner midtpunktet av en linje. Gitt at p og q er punkter og p x gir x-koordinat så gir ( px+qx 2, py+qy 2 ) midtpunktet av en linje, dette kan vi uttrykke ved å bruke abstraksjonene vi har skrevet. (define (midpoint-segment seq) (let ((p (start-segment seq)) (q (end-segment seq))) (make-point (/ (+ (x-point p) (x-point q)) 2) (/ (+ (y-point p) (y-point q)) 2)))) Gitt prosedyren ovenfor er det ikke så vanskelig å finne formelen den representerer, men hvis vi tar vekk abstraksjonene blir dette mye vanskeligere, og det vanskeligere å forstå hvorfor prosedyren fungerer. (define (midpoint-segment seg) (let ((p (car seg)) (q (cdr seg))) (cons (/ (+ (car p) (car q)) 2) (/ (+ (cdr p) (cdr q)) 2)))) Exercise 2.3 Implement a representation for rectangles in a plane. (Hint: You may want to make use of exercise 2.2.) In terms of your constructors and selectors, create procedures that compute the perimeter and the area of a given rectangle. Now implement a different representation for rectangles. Can you design your system with suitable abstraction barriers, so that the same perimeter and area procedures will work using either representation? TODO Alt vi trenger for å kunne gi en fullstendig beskrivelse av et rektangel er høyden og bredden på rektangelet. Vi antar at vi nå kan ta i mot et rektangel rec der vi kan bruke prosedyrene rec-height og rec-width for å hhv. aksessere høyden og bredden på rektangelet rec. Da kan vi uttrykke omkretsen slik. 32

33 (define (perimeter rec) (+ (* 2 (rec-heigt rec)) (* 2 (rec-width rec)))) Arealet av rektangelet kan uttrykkes slik. (define (area rec) (* (rec-heigt rec) (rec-width rec))) Nå skal vi lage abstraksjoner for rektangelet, slik at vi faktisk kan bruke prosedyrene ovenfor. Vi kan først representere et rektangel som to linje-segmenter, der vi fullfører rektangelet. Vi antar at start-segment i de to linje-segmentene er samme punkt, og at det er 90 mellom de. (define (make-rec seg1 seg2) (cons seg1 seg2)) (define (rec-heigt rec) (let ((seg (car rec))) (- (abs (end-segment seg)) (start-segment seg)))) (define (rec-width rec) (let ((seg (cdr rec))) (- (abs (end-segment seg)) (start-segment seg)))) Exercise 2.24 Suppose we evaluate the expression (list 1 (list 2 (list 3 4))). Give the result printed by the interpreter, the corresponding box-and-pointer structure, and the interpretation of this as a tree (as in figure 2.6). list er en prosedyre som tar et vilkårlig antall argumenter og pakker disse inn i en liste. Uttrykket (list 1 (list 2 (list 3 4))) vil evalueres til lista (1 (2 (3 4))). 33

34 Vi kan representere den samme lista med et boks-og-peker diagram slik: ;;; ;;; > + / + ;;; ;;; ;;; v v ;;; ;;; > + / + ;;; ;;; ;;; v v ;;; ;;; > + / + ;;; ;;; ;;; v v ;;; 3 4 Og vi kan representere listestrukturen som et tre. ;;; /\ ;;; / \ ;;; 1 /\ ;;; / \ ;;; 2 /\ ;;; / \ ;;; 3 4 Exercise 2.25 Give combinations of car s and cdr s that will pick 7 from each of the following lists: (1 3 (5 7) 9) ((7)) (1 (2 (3 (4 (5 (6 7)))))) 34

35 Disse oppgavene er ment for å gi trening i car og cdr. Vanligvis vil vi aldri skrive så sammensatte uttrykk av car og cdr i koden vår, siden det tyder på dårlig bruk av abstraksjoner. Her er det bare å holde hodet kaldt og huske at car gir deg det første elementet i lista, og cdr gir deg det som er igjen etter å ha fjernet det første elementet i lista (altså resten). Merk at det er her er tatt noen friheter med henhold til indenteringsregler, siden uttrykket ble veldig stygt uten. Vanligvis anbefales det å la editoren din avgjøre indentering. (car (cdr (car (cdr (cdr '(1 3 (5 7) 9)))))) ;;; Forkortet: (car (cdaddr '(1 3 (5 7) 9))) (car (car '((7)))) ;;; Forkortet (caar '((7))) (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr '(1 (2 (3 (4 (5 (6 7)))))))))))))))))) ;;; Forkortet: (cadadr (cadadr (cadadr '(1 (2 (3 (4 (5 (6 7))))))))) Exercise 2.26 Suppose we define x and y to be two lists: (define x (list 1 2 3)) (define y (list 4 5 6)) What result is printed by the interpreter in response to evaluating each of the following expressions: (append x y) (cons x y) 35

36 (list x y) Prosedyren append tar to lister inn som argument, og rekursivt samler opp elementene i den første lista, og returnerer den andre lista i sitt basistilfellet. En annen måte å tenke på det er at den bytter ut den tomme lista i den første lista med den andre lista. Her anbefales det å skrive append selv for å være sikker på at man skjønner hvordan den fungerer. Prøv også å tegn boks-og-peker diagrammer for å videre forbedre forståelsen. (append x y) ; => ( ) cons lager et par av de to argumentene den får inn. Det første argumentet er lista (1 2 3), og det andre argumentet er også en liste. Da vil vi få en liste der lista (1 2 3) er første element, og elementene i (4 5 6) er de tre resterende elementene i lista. (cons x y) ; => ((1 2 3) 4 5 6) list tar et vilkårlig antall argumenter og pakker disse inn i en liste. Siden list får to lister som argumenter vil vi få tilbake en liste med to elementer, der begge elementene er lister. (list x y) ; => ((1 2 3) (4 5 6)) Exercise 2.27 Modify your reverse procedure of exercise 2.18 to produce a deep-reverse procedure that takes a list as argument and returns as its value the list with its elements reversed and with all sublists deep-reversed as well. For example, (define x (list (list 1 2) (list 3 4))) x ((1 2) (3 4)) (reverse x) ((3 4) (1 2)) 36

37 (deep-reverse x) ((4 3) (2 1)) Det eneste vi må gjøre anderledes fra 2.18 er å sjekke om elementet vi har kommet til er en liste, og i så fall kjøre deep-reverse på denne før den cons es på resultatet. (define (deep-reverse lst) (define (reverse lst res) (cond ((null? lst) res) ((list? (car lst)) (reverse (cdr lst) (cons (deep-reverse (car lst)) res))) (else (reverse (cdr lst) (cons (car lst) res))))) (reverse lst '())) Exercise 2.28 Write a procedure fringe that takes as argument a tree (represented as a list) and returns a list whose elements are all the leaves of the tree arranged in left-to-right order. For example, (define x (list (list 1 2) (list 3 4))) (fringe x) ( ) (fringe (list x x)) ( ) Et vanlig navn på denne prosedyren er flatten, som kanskje i større grad beskriver hva den gjør; den flater ut en liste. I likhet med deep-reverse må vi ta høyde for at elementet vi har kommet til er en liste, og i så fall kjøre fringe på den. Siden fringe returnerer en liste, og denne skal slås sammen med (fringe (cdr tree)) som også returnerer en liste bør vi bruke append fremfor cons, siden cons brukes for å legge inn ett element i starten av lista. 37

38 (define (fringe tree) (cond ((null? tree) '()) ((list? (car tree)) (append (fringe (car tree)) (fringe (cdr tree)))) (else (cons (car tree) (fringe (cdr tree)))))) Exercise 2.30 Define a procedure square-tree analogous to the square-list procedure of exercise That is, square-list should behave as follows: (square-tree (list 1 (list 2 (list 3 4) 5) (list 6 7))) (1 (4 (9 16) 25) (36 49)) Define square-tree both directly (i.e., without using any higher-order procedures) and also by using map and recursion. Dersom det første elementet i tree er en liste må vi kalle square-tree på dette elementet, og slå det sammen med et rekursivt kall på (square-tre (cdr tree)). (define (square-tree tree) (cond ((null? tree) '()) ((number? (car tree)) (cons (square (car tree)) (square-tree (cdr tree)))) (else (cons (square-tree (car tree)) (square-tree (cdr tree)))))) Dette lar seg uttrykkes med å map e over et tre, der vi kvadrerer input dersom det er et tall, ellers kaller square-tree rekursivt. (define (square-tree tree) (map (lambda (x) (if (number? x) (square x) (square-tree x))) tree)) 38

39 Merk at vi har valgt å dra nytte av at vi vet at løvnodene vil inneholde tall, slik at vi kan teste om elementet er et tall fremfor å teste om det er en liste. Dette er siden number? kjører på konstant tid, mens list? kjører på lineær tid. Exercise 2.31 Abstract your answer to exercise 2.30 to produce a procedure tree-map with the property that square-tree could be defined as (define (square-tree tree) (tree-map square tree)) Det eneste som må endres fra oppgave 2.30 er at prosedyren som skal anvendes på elementene i treet, ikke (nødvendigvis) er square, men skal tas som argument. Siden vi dro nytte av at square-tree tar inn trær med tall i løvnodene, må vi også endre number? til det mer generelle tilfellet list?. Vi løser den uten høyere-ordens prosedyrer først. (define (tree-map f tree) (cond ((null? tree) '()) ((list? (car tree)) (cons (tree-map f (car tree)) (tree-map f (cdr tree)))) (else (cons (f (car tree)) (tree-map f (cdr tree)))))) Her er mer abstrahert som tar bruk av map. Siden oppgaven bare ber om en variant ville denne vært å foretrekke siden den er skrevet på et høyere abstraksjonsnivå. (define (tree-map f tree) (map (lambda (x) (if (list? x) (tree-map f x) (f x))) tree)) Takk til Esben som oppdaget en feil som hadde sneket seg inn i løsningsforslaget! 39

40 Uke 10 Denne uken gås det gjennom løsninger på enkelte oppgaver fra oblig 1b. Det er ikke gitt noen flere ukesoppgaver denne uken, så det kan være lurt på å hente seg inn på oppgaver man ikke har gjort fra uke 8 og 9. Uke 11 Koding av oppgavesett 2a. Exercise 2.20 The procedures +, *, and list take arbitrary numbers of arguments. One way to define such procedures is to use define with dotted-tail notation. In a procedure definition, a parameter list that has a dot before the last parameter name indicates that, when the procedure is called, the initial parameters (if any) will have as values the initial arguments, as usual, but the final parameter s value will be a list of any remaining arguments. For instance, given the definition (define (f x y. z) <body>) the procedure f can be called with two or more arguments. If we evaluate (f ) then in the body of f, x will be 1, y will be 2, and z will be the list ( ). Given the definition (define (g. w) <body>) the procedure g can be called with zero or more arguments. If we evaluate (g ) then in the body of g, w will be the list ( ). Use this notation to write a procedure same-parity that takes one or more integers and returns a list of all the arguments that have the same even-odd parity as the first argument. For example, 40

INF2810: Funksjonell Programmering. Lister og høyereordens prosedyrer

INF2810: Funksjonell Programmering. Lister og høyereordens prosedyrer INF2810: Funksjonell Programmering Lister og høyereordens prosedyrer Erik Velldal Universitetet i Oslo 2. februar 2017 Agenda 2 Forrige uke Substitusjonsmodellen og evalueringsstrategier. Blokkstruktur

Detaljer

INF2810: Funksjonell Programmering. Lister og høyereordens prosedyrer

INF2810: Funksjonell Programmering. Lister og høyereordens prosedyrer INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Lister og høyereordens prosedyrer Erik Velldal Universitetet i Oslo 5. februar 2015 Agenda Forrige uke Substitusjonsmodellen og evalueringsstrategier.

Detaljer

Høyere-ordens prosedyrer

Høyere-ordens prosedyrer INF2810: Funksjonell programmering Høyere-ordens prosedyrer Stephan Oepen & Erik Velldal Universitetet i Oslo 8. februar, 2013 Tema 2 Forrige uke Lister og listerekursjon Høyere-ordens prosedyrer Prosedyrer

Detaljer

INF2810: Funksjonell Programmering. Kommentarer til prøveeksamen

INF2810: Funksjonell Programmering. Kommentarer til prøveeksamen INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Kommentarer til prøveeksamen Erik Velldal Universitetet i Oslo 1: Grunnleggende (6 poeng)? (define foo '(a b))? (define bar foo)? (set!

Detaljer

INF2810: Funksjonell Programmering. Dataabstraksjon og Trerekursjon

INF2810: Funksjonell Programmering. Dataabstraksjon og Trerekursjon INF2810: Funksjonell Programmering Dataabstraksjon og Trerekursjon Stephan Oepen & Erik Velldal Universitetet i Oslo 15. februar, 2013 Tema 2 Forrige uke Høyere-ordens prosedyrer: Prosedyrer som argumenter

Detaljer

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme, del 2

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme, del 2 INF2810: Funksjonell programmering INF2810: Funksjonell Programmering En Scheme-evaluator i Scheme, del 2 Erik Velldal Universitetet i Oslo 7. mai 2015 Tema Forrige uke SICP 4.1. Structure and interpretation

Detaljer

INF2810: Funksjonell Programmering. En metasirkulær evaluator, del 2

INF2810: Funksjonell Programmering. En metasirkulær evaluator, del 2 INF2810: Funksjonell Programmering En metasirkulær evaluator, del 2 Stephan Oepen & Erik Velldal Universitetet i Oslo 03. mai 2013 Tema 2 Forrige uke SICP 4.1. Structure and interpretation of computer

Detaljer

INF2810: Funksjonell Programmering. En metasirkulær evaluator, del 2

INF2810: Funksjonell Programmering. En metasirkulær evaluator, del 2 INF2810: Funksjonell Programmering En metasirkulær evaluator, del 2 Stephan Oepen & Erik Velldal Universitetet i Oslo 03. mai 2013 Tema 2 Forrige uke SICP 4.1. Structure and interpretation of computer

Detaljer

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme, del 2

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme, del 2 INF2810: Funksjonell Programmering En Scheme-evaluator i Scheme, del 2 Erik Velldal Universitetet i Oslo 4. mai 2017 Tema 2 Forrige uke SICP 4.1. Structure and interpretation of computer programs Metacircular

Detaljer

INF2810: Funksjonell Programmering

INF2810: Funksjonell Programmering INF2810: Funksjonell Programmering Høyereordens prosedyrer, lambda og lokale variabler Erik Velldal Universitetet i Oslo 9. februar 2017 Tema 2 Forrige uke Lister og listerekursjon quote Høyereordens prosedyrer

Detaljer

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme, del 2

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme, del 2 INF2810: Funksjonell Programmering En Scheme-evaluator i Scheme, del 2 Erik Velldal Universitetet i Oslo 4. mai 2017 Tema 2 Forrige uke SICP 4.1. Structure and interpretation of computer programs Metacircular

Detaljer

INF2810: Funksjonell Programmering

INF2810: Funksjonell Programmering INF2810: Funksjonell Programmering Høyereordens prosedyrer, lambda og lokale variabler Erik Velldal Universitetet i Oslo 9. februar 2017 Tema 2 Forrige uke Lister og listerekursjon quote Høyereordens prosedyrer

Detaljer

INF2810: Funksjonell Programmering. Lokale variabler. Og trær.

INF2810: Funksjonell Programmering. Lokale variabler. Og trær. INF2810: Funksjonell Programmering Lokale variabler. Og trær. Erik Velldal Universitetet i Oslo 11. september 2019 Tema forrige uke 2 Lister som datastruktur quote Rekursjon på lister Høyereordens prosedyrer

Detaljer

Rekursjon og lister. Stephan Oepen & Erik Velldal. 1. februar, Universitetet i Oslo

Rekursjon og lister. Stephan Oepen & Erik Velldal. 1. februar, Universitetet i Oslo INF2810: Funksjonell programmering Rekursjon og lister Stephan Oepen & Erik Velldal Universitetet i Oslo 1. februar, 2013 Agenda 2 Forrige uke Scheme Substitusjonsmodellen Blokkstruktur Predikater Kondisjonale

Detaljer

INF2810: Funksjonell Programmering. Lokale variabler. Og trær.

INF2810: Funksjonell Programmering. Lokale variabler. Og trær. INF2810: Funksjonell Programmering Lokale variabler. Og trær. Erik Velldal Universitetet i Oslo 11. september 2019 Tema forrige uke 2 Lister som datastruktur quote Rekursjon på lister Høyereordens prosedyrer

Detaljer

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme INF2810: Funksjonell Programmering En Scheme-evaluator i Scheme Erik Velldal Universitetet i Oslo 19. april 2016 Tema 2 Forrige uke Strømmer og utsatt evaluering Kort om makroer I dag Kap. 4 Metasirkulær

Detaljer

INF2810: Funksjonell Programmering. En metasirkulær evaluator

INF2810: Funksjonell Programmering. En metasirkulær evaluator INF2810: Funksjonell Programmering En metasirkulær evaluator Stephan Oepen & Erik Velldal Universitetet i Oslo 26. april 2013 Tema 2 Forrige uke Strømmer og utsatt evaluering Memoisering Kort om makroer

Detaljer

INF2810: Funksjonell Programmering. En metasirkulær evaluator

INF2810: Funksjonell Programmering. En metasirkulær evaluator INF2810: Funksjonell Programmering En metasirkulær evaluator Stephan Oepen & Erik Velldal Universitetet i Oslo 26. april 2013 Tema 2 Forrige uke Strømmer og utsatt evaluering Memoisering Kort om makroer

Detaljer

INF2810: Funksjonell Programmering

INF2810: Funksjonell Programmering INF2810: Funksjonell Programmering Høyereordens prosedyrer, lambda og lokale variabler Stephan Oepen Universitetet i Oslo 9. februar 2015 Tema 2 Forrige uke Lister og listerekursjon quote Høyereordens

Detaljer

INF2810: Funksjonell Programmering

INF2810: Funksjonell Programmering INF2810: Funksjonell Programmering Høyereordens prosedyrer, lambda og lokale variabler Stephan Oepen Universitetet i Oslo 9. februar 2015 Tema 2 Forrige uke Lister og listerekursjon quote Høyereordens

Detaljer

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme

INF2810: Funksjonell Programmering. En Scheme-evaluator i Scheme INF2810: Funksjonell Programmering En Scheme-evaluator i Scheme Erik Velldal Universitetet i Oslo 27. april 2017 Tema 2 Forrige forelesning Strømmer og utsatt evaluering Kort om makroer I dag Kap. 4 Metasirkulær

Detaljer

Slope-Intercept Formula

Slope-Intercept Formula LESSON 7 Slope Intercept Formula LESSON 7 Slope-Intercept Formula Here are two new words that describe lines slope and intercept. The slope is given by m (a mountain has slope and starts with m), and intercept

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Eksamen i: INF2810 Eksamensdag: 5. juni, 2014 Tid for eksamen: 14:30 (4 timer) Oppgavesettet er på 4 sider. Vedlegg: Ingen Tillatte hjelpemidler:

Detaljer

INF2810: Funksjonell Programmering. Strømmer og utsatt evaluering

INF2810: Funksjonell Programmering. Strømmer og utsatt evaluering INF2810: Funksjonell Programmering Strømmer og utsatt evaluering Stephan Oepen Universitetet i Oslo 30. mars 2017 Forrige forelesning 2 Mer om (prosedyre)navn, bindinger, og verditilordning Nok en ny abstrakt

Detaljer

Unit Relational Algebra 1 1. Relational Algebra 1. Unit 3.3

Unit Relational Algebra 1 1. Relational Algebra 1. Unit 3.3 Relational Algebra 1 Unit 3.3 Unit 3.3 - Relational Algebra 1 1 Relational Algebra Relational Algebra is : the formal description of how a relational database operates the mathematics which underpin SQL

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Eksamen i INF 3230 Formell modellering og analyse av kommuniserende systemer Eksamensdag: 4. april 2008 Tid for eksamen: 9.00 12.00 Oppgavesettet

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Eksamen i INF 3230 Formell modellering og analyse av kommuniserende systemer Eksamensdag: 4. juni 2010 Tid for eksamen: 9.00 12.00 Oppgavesettet

Detaljer

INF2810: Funksjonell Programmering. Strømmer og utsatt evaluering

INF2810: Funksjonell Programmering. Strømmer og utsatt evaluering INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Strømmer og utsatt evaluering Erik Velldal Universitetet i Oslo 5. april 2016 Forrige forelesning Mer om (prosedyre)navn, bindinger,

Detaljer

Neural Network. Sensors Sorter

Neural Network. Sensors Sorter CSC 302 1.5 Neural Networks Simple Neural Nets for Pattern Recognition 1 Apple-Banana Sorter Neural Network Sensors Sorter Apples Bananas 2 Prototype Vectors Measurement vector p = [shape, texture, weight]

Detaljer

Databases 1. Extended Relational Algebra

Databases 1. Extended Relational Algebra Databases 1 Extended Relational Algebra Relational Algebra What is an Algebra? Mathematical system consisting of: Operands --- variables or values from which new values can be constructed. Operators ---

Detaljer

Call function of two parameters

Call function of two parameters Call function of two parameters APPLYUSER USER x fµ 1 x 2 eµ x 1 x 2 distinct e 1 0 0 v 1 1 1 e 2 1 1 v 2 2 2 2 e x 1 v 1 x 2 v 2 v APPLY f e 1 e 2 0 v 2 0 µ Evaluating function application The math demands

Detaljer

INF2810: Funksjonell Programmering. Eksamensforberedelser

INF2810: Funksjonell Programmering. Eksamensforberedelser INF2810: Funksjonell Programmering Eksamensforberedelser Stephan Oepen & Erik Velldal Universitetet i Oslo 24. mai 2013 I dag 2 Kort oppsummering Praktisk om eksamen Hvem vant konkurransen om flest oblig-poeng

Detaljer

INF2810: Funksjonell Programmering. Trær og mengder

INF2810: Funksjonell Programmering. Trær og mengder INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Trær og mengder Erik Velldal Universitetet i Oslo 19. februar 2015 Tema Forrige uke Høyereordens prosedyrer lambda, let og lokale variabler

Detaljer

INF2810: Funksjonell Programmering. Trær og mengder

INF2810: Funksjonell Programmering. Trær og mengder INF2810: Funksjonell Programmering Trær og mengder Stephan Oepen Universitetet i Oslo 16. februar 2017 Tema 2 Forrige uke Høyereordens prosedyrer lambda, let og lokale variabler Dataabstraksjon I dag Lister

Detaljer

INF2810: Funksjonell Programmering. Mer om verditilordning. Tabeller. Og strømmer.

INF2810: Funksjonell Programmering. Mer om verditilordning. Tabeller. Og strømmer. INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Mer om verditilordning. Tabeller. Og strømmer. Erik Velldal Universitetet i Oslo 29. mars 2016 De siste ukene: destruktive operasjoner

Detaljer

Vi skal se på lambda-uttrykk. Følgende er definerte og vil bli brukt gjennom oppgaven

Vi skal se på lambda-uttrykk. Følgende er definerte og vil bli brukt gjennom oppgaven SLI 230 - side 2 av 8 EKSAMENSOPPGAVE - SLI 230 - VÅR 2000 Nedenfor følger eksamensoppgaver i SLI 230. Først om oppgavene Bakerst følger to sider med hjelp slik det er avtalt - liste over primitiver fra

Detaljer

Maple Basics. K. Cooper

Maple Basics. K. Cooper Basics K. Cooper 2012 History History 1982 Macsyma/MIT 1988 Mathematica/Wolfram 1988 /Waterloo Others later History Why? Prevent silly mistakes Time Complexity Plots Generate LATEX This is the 21st century;

Detaljer

INF2810: Funksjonell Programmering. Mer om verditilordning. Tabeller. Og strømmer.

INF2810: Funksjonell Programmering. Mer om verditilordning. Tabeller. Og strømmer. INF2810: Funksjonell Programmering Mer om verditilordning. Tabeller. Og strømmer. Erik Velldal Universitetet i Oslo 29. mars 2016 De siste ukene: destruktive operasjoner 2 set! endrer verditilordningen

Detaljer

INF2810: Funksjonell Programmering

INF2810: Funksjonell Programmering INF2810: Funksjonell Programmering Omgivelsesmodeller og destruktive listeoperasjoner Stephan Oepen & Erik Velldal Universitetet i Oslo 15. mars 2013 Tema 2 Forrige uke Representasjon av mengder Sorterte

Detaljer

UNIVERSITY OF OSLO DEPARTMENT OF ECONOMICS

UNIVERSITY OF OSLO DEPARTMENT OF ECONOMICS UNIVERSITY OF OSLO DEPARTMENT OF ECONOMICS Postponed exam: ECON420 Mathematics 2: Calculus and linear algebra Date of exam: Tuesday, June 8, 203 Time for exam: 09:00 a.m. 2:00 noon The problem set covers

Detaljer

INF2810: Funksjonell Programmering. Mer om verditilordning og muterbare data.

INF2810: Funksjonell Programmering. Mer om verditilordning og muterbare data. INF2810: Funksjonell Programmering Mer om verditilordning og muterbare data. Erik Velldal Universitetet i Oslo 16. mars 2017 De siste ukene: destruktive operasjoner 2 set! endrer verditilordningen til

Detaljer

INF2810: Funksjonell Programmering. Trær og mengder

INF2810: Funksjonell Programmering. Trær og mengder INF2810: Funksjonell Programmering Trær og mengder Stephan Oepen Universitetet i Oslo 16. februar 2016 Tema 2 Forrige uke Høyereordens prosedyrer lambda, let og lokale variabler Dataabstraksjon I dag Lister

Detaljer

INF2810: Funksjonell Programmering. Mer om verditilordning og muterbare data.

INF2810: Funksjonell Programmering. Mer om verditilordning og muterbare data. INF2810: Funksjonell Programmering Mer om verditilordning og muterbare data. Erik Velldal Universitetet i Oslo 16. mars 2017 De siste ukene: destruktive operasjoner 2 set! endrer verditilordningen til

Detaljer

INF2810: Funksjonell programmering: Mer om Scheme. Rekursjon og iterasjon.

INF2810: Funksjonell programmering: Mer om Scheme. Rekursjon og iterasjon. INF2810: Funksjonell programmering: Mer om Scheme. Rekursjon og iterasjon. Stephan Oepen & Erik Velldal Universitetet i Oslo 25. januar, 2013 På blokka 2 Forrige uke Introduksjon og oversikt Funksjonell

Detaljer

INF2810: Funksjonell Programmering

INF2810: Funksjonell Programmering INF2810: Funksjonell Programmering Omgivelsesmodeller og destruktive listeoperasjoner Stephan Oepen & Erik Velldal Universitetet i Oslo 15. mars 2013 Tema 2 Forrige uke Representasjon av mengder Sorterte

Detaljer

Hvor mye praktisk kunnskap har du tilegnet deg på dette emnet? (1 = ingen, 5 = mye)

Hvor mye praktisk kunnskap har du tilegnet deg på dette emnet? (1 = ingen, 5 = mye) INF247 Er du? Er du? - Annet Ph.D. Student Hvor mye teoretisk kunnskap har du tilegnet deg på dette emnet? (1 = ingen, 5 = mye) Hvor mye praktisk kunnskap har du tilegnet deg på dette emnet? (1 = ingen,

Detaljer

INF2810: Funksjonell Programmering. Mer om strømmer

INF2810: Funksjonell Programmering. Mer om strømmer INF2810: Funksjonell Programmering Mer om strømmer Stephan Oepen & Erik Velldal Universitetet i Oslo 19. april 2013 Tema 2 Forrige uke Repetisjon: parallelitet Noe helt nytt: strømmer Noe quizzaktivitet

Detaljer

INF2810: Funksjonell Programmering. Mer om strømmer

INF2810: Funksjonell Programmering. Mer om strømmer INF2810: Funksjonell Programmering Mer om strømmer Stephan Oepen & Erik Velldal Universitetet i Oslo 19. april 2013 Tema 2 Forrige uke Repetisjon: parallelitet Noe helt nytt: strømmer Noe quizzaktivitet

Detaljer

Trigonometric Substitution

Trigonometric Substitution Trigonometric Substitution Alvin Lin Calculus II: August 06 - December 06 Trigonometric Substitution sin 4 (x) cos (x) dx When you have a product of sin and cos of different powers, you have three different

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Eksamen i INF 3230/4230 Formell modellering og analyse av kommuniserende systemer Eksamensdag: 24. mars 2006 Tid for eksamen: 13.30 16.30

Detaljer

INF2810: Funksjonell Programmering. Køer, tabeller, og (litt om) parallelitet

INF2810: Funksjonell Programmering. Køer, tabeller, og (litt om) parallelitet INF2810: Funksjonell Programmering Køer, tabeller, og (litt om) parallelitet Stephan Oepen & Erik Velldal Universitetet i Oslo 5. april 2013 Tema 2 Siste gang Kort om underveisevaluering Destruktive listeoperasjoner

Detaljer

INF2810: Funksjonell Programmering. Utsatt evaluering og strømmer

INF2810: Funksjonell Programmering. Utsatt evaluering og strømmer INF2810: Funksjonell Programmering Utsatt evaluering og strømmer Erik Velldal Universitetet i Oslo 12. april 2016 Tema 2 Forrige gang Ny datastruktur, ny teknikk: Strømmer Utsatt evaluering Uendelige sekvenser

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Eksamen i: INF2810 Eksamensdag: Fredag 5. juni 2015 Tid for eksamen: 14:30 (4 timer) Oppgavesettet er på 4 sider (ikke medregnet denne siden)

Detaljer

INF2810: Funksjonell Programmering. Køer, tabeller, og (litt om) parallelitet

INF2810: Funksjonell Programmering. Køer, tabeller, og (litt om) parallelitet INF2810: Funksjonell Programmering Køer, tabeller, og (litt om) parallelitet Stephan Oepen & Erik Velldal Universitetet i Oslo 5. april 2013 Tema 2 Siste gang Kort om underveisevaluering Destruktive listeoperasjoner

Detaljer

Appendiks A Kontinuasjoner

Appendiks A Kontinuasjoner Appendiks A Kontinuasjoner Fra R5RS: "Whenever a Scheme expression is evaluated there is a continuation wanting the result of the expression." Eller med andre ord: En kontinuasjon i et program under utførelse

Detaljer

INF2810: Funksjonell Programmering. Lister og høyereordens prosedyrer

INF2810: Funksjonell Programmering. Lister og høyereordens prosedyrer INF2810: Funksjonell Programmering Lister og høyereordens prosedyrer Stephan Oepen Universitetet i Oslo 2. februar 2016 Agenda 2 Forrige uke Substitusjonsmodellen og evalueringsstrategier Blokkstruktur

Detaljer

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

Gjennomgåelse av eksamensoppgaven i HUMIT2710 fra våren 2004 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

Detaljer

LISP PVV-kurs 25. oktober 2012

LISP PVV-kurs 25. oktober 2012 LISP PVV-kurs 25. oktober 2012 Hva er Lisp? Grunnleggende konsepter Variabler (Pause) Lister Løkker Funksjoner Oversikt over kurset Først: Få tak i en implementasjon av Common Lisp Mange implementasjoner

Detaljer

INF2810: Funksjonell Programmering. Utsatt evaluering og strømmer

INF2810: Funksjonell Programmering. Utsatt evaluering og strømmer INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Utsatt evaluering og strømmer Erik Velldal Universitetet i Oslo 12. april 2016 Tema Forrige gang Ny datastruktur, ny teknikk: Strømmer

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Eksamen i MAT2400 Analyse 1. Eksamensdag: Onsdag 15. juni 2011. Tid for eksamen: 09.00 13.00 Oppgavesettet er på 6 sider. Vedlegg: Tillatte

Detaljer

Dynamic Programming Longest Common Subsequence. Class 27

Dynamic Programming Longest Common Subsequence. Class 27 Dynamic Programming Longest Common Subsequence Class 27 Protein a protein is a complex molecule composed of long single-strand chains of amino acid molecules there are 20 amino acids that make up proteins

Detaljer

UNIVERSITETET I OSLO ØKONOMISK INSTITUTT

UNIVERSITETET I OSLO ØKONOMISK INSTITUTT UNIVERSITETET I OSLO ØKONOMISK INSTITUTT Exam: ECON320/420 Mathematics 2: Calculus and Linear Algebra Eksamen i: ECON320/420 Matematikk 2: Matematisk analyse og lineær algebra Date of exam: Friday, May

Detaljer

INF2810: Funksjonell Programmering. Utsatt evaluering og strømmer

INF2810: Funksjonell Programmering. Utsatt evaluering og strømmer INF2810: Funksjonell Programmering Utsatt evaluering og strømmer Stephan oepen Universitetet i Oslo 6. april 2017 Tema 2 Forrige gang Ny datastruktur, ny teknikk: Strømmer Utsatt evaluering I dag Uendelige

Detaljer

(define (naer-nok-kuberot? y x) (< (abs (- (kube y) x)) 0.001)) (define (naermere-kuberot y x) (/ (+ (* y 2) (/ x (kvadrat y))) 3))

(define (naer-nok-kuberot? y x) (< (abs (- (kube y) x)) 0.001)) (define (naermere-kuberot y x) (/ (+ (* y 2) (/ x (kvadrat y))) 3)) Oppgave 1 For å komme nærmere kuberoten (tredjeroten) til et tall x fra en foreløpig tilnærming y, kan vi bruke formelen (2y + x/y 2 )/3. Skriv prosedyrene (nær-nok-kuberot? y x), (nærmere-kuberot y x)

Detaljer

Moving Objects. We need to move our objects in 3D space.

Moving Objects. We need to move our objects in 3D space. Transformations Moving Objects We need to move our objects in 3D space. Moving Objects We need to move our objects in 3D space. An object/model (box, car, building, character,... ) is defined in one position

Detaljer

Eksamen i HUMIT 2710, Funksjonell programmering, våren Ingen hjelpemidler er tillatt. <resten av forsiden> Side 1 av 7

Eksamen i HUMIT 2710, Funksjonell programmering, våren Ingen hjelpemidler er tillatt. <resten av forsiden> Side 1 av 7 Eksamen i HUMIT 2710, Funksjonell programmering, våren 2005 Ingen hjelpemidler er tillatt. Side 1 av 7 Oppgave 1 Rekursjon Fakultetsfunksjonen, her kalt Fak, kan defineres rekursivt

Detaljer

Lisp 2: Lister og funksjoner

Lisp 2: Lister og funksjoner Eirik Alderslyst Nygaard Øystein Ingmar Skartsæterhagen Programvareverkstedet 11. mars 2010 (Lister) (Par) (Listeoperasjoner) (Assosiasjonslister)... lists are the heart of Lisp... Guy L. Steele Jr. (Par)

Detaljer

Side 1. Oppgave 1. Prosedyrer 1.1. Prosedyrene f og g skal begge returnere prosedyrer. a. Skriv f slik at ((f a) b) returnerer summen av a og b.

Side 1. Oppgave 1. Prosedyrer 1.1. Prosedyrene f og g skal begge returnere prosedyrer. a. Skriv f slik at ((f a) b) returnerer summen av a og b. Side 1 Oppgave 1. Prosedyrer 1.1. Prosedyrene f og g skal begge returnere prosedyrer. a. Skriv f slik at ((f a) b) returnerer summen av a og b. (define (f a) (lambda (b) (add a b ))) b. Skriv g, uten å

Detaljer

INF2810: Funksjonell Programmering. Utsatt evaluering og strømmer

INF2810: Funksjonell Programmering. Utsatt evaluering og strømmer INF2810: Funksjonell Programmering Utsatt evaluering og strømmer Stephan oepen Universitetet i Oslo 6. april 2017 Tema 2 Forrige gang Ny datastruktur, ny teknikk: Strømmer Utsatt evaluering I dag Uendelige

Detaljer

INF2810: Funksjonell Programmering. Tilstand og verditilordning

INF2810: Funksjonell Programmering. Tilstand og verditilordning INF2810: Funksjonell Programmering Tilstand og verditilordning Stephan Oepen Universitetet i Oslo 2. mars 2017 Forrige gang 2 I dag 3 Vi blar om til kapittel 3 i SICP. Tilstand og verditilordning. Destruktive

Detaljer

Innlevering 2a i INF2810, vår 2017

Innlevering 2a i INF2810, vår 2017 Innlevering 2a i INF2810, vår 2017 Hovedtematikken denne gang er Huffman-koding, som ble dekket i 6. forelesning (23. februar) og i seksjon 2.3.4 i SICP. Det er viktig å ha lest denne seksjonen før dere

Detaljer

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser INF2810: Funksjonell Programmering Oppsummering og eksamensforberedelser Erik Velldal & Stephan Oepen Universitetet i Oslo 18. mai 2017 I dag 2 Kort oppsummering Praktisk om eksamen Hvem vant konkurransen

Detaljer

INF2810: Funksjonell Programmering. Tilstand og verditilordning

INF2810: Funksjonell Programmering. Tilstand og verditilordning INF2810: Funksjonell Programmering Tilstand og verditilordning Stephan Oepen Universitetet i Oslo 8. mars 2016 Forrige gang 2 I dag 3 Vi blar om til kapittel 3 i SICP. Tilstand og verditilordning. Destruktive

Detaljer

INF2810: Funksjonell Programmering. Tilstand og verditilordning

INF2810: Funksjonell Programmering. Tilstand og verditilordning INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Tilstand og verditilordning Erik Velldal Universitetet i Oslo 26. februar 2015 Forrige gang 2 I dag Vi blar om til kapittel 3 i SICP.

Detaljer

Andrew Gendreau, Olga Rosenbaum, Anthony Taylor, Kenneth Wong, Karl Dusen

Andrew Gendreau, Olga Rosenbaum, Anthony Taylor, Kenneth Wong, Karl Dusen Andrew Gendreau, Olga Rosenbaum, Anthony Taylor, Kenneth Wong, Karl Dusen The Process Goal Definition Data Collection Data Preprocessing EDA Choice of Variables Choice of Method(s) Performance Evaluation

Detaljer

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser INF2810: Funksjonell Programmering Oppsummering og eksamensforberedelser Erik Velldal & Stephan Oepen Universitetet i Oslo 18. mai 2017 I dag 2 Kort oppsummering Praktisk om eksamen Hvem vant konkurransen

Detaljer

Du må håndtere disse hendelsene ved å implementere funksjonene init(), changeh(), changev() og escape(), som beskrevet nedenfor.

Du må håndtere disse hendelsene ved å implementere funksjonene init(), changeh(), changev() og escape(), som beskrevet nedenfor. 6-13 July 2013 Brisbane, Australia Norwegian 1.0 Brisbane har blitt tatt over av store, muterte wombater, og du må lede folket i sikkerhet. Veiene i Brisbane danner et stort rutenett. Det finnes R horisontale

Detaljer

Mathematics 114Q Integration Practice Problems SOLUTIONS. = 1 8 (x2 +5x) 8 + C. [u = x 2 +5x] = 1 11 (3 x)11 + C. [u =3 x] = 2 (7x + 9)3/2

Mathematics 114Q Integration Practice Problems SOLUTIONS. = 1 8 (x2 +5x) 8 + C. [u = x 2 +5x] = 1 11 (3 x)11 + C. [u =3 x] = 2 (7x + 9)3/2 Mathematics 4Q Name: SOLUTIONS. (x + 5)(x +5x) 7 8 (x +5x) 8 + C [u x +5x]. (3 x) (3 x) + C [u 3 x] 3. 7x +9 (7x + 9)3/ [u 7x + 9] 4. x 3 ( + x 4 ) /3 3 8 ( + x4 ) /3 + C [u + x 4 ] 5. e 5x+ 5 e5x+ + C

Detaljer

INF2810: Funksjonell Programmering. Tilstand og verditilordning

INF2810: Funksjonell Programmering. Tilstand og verditilordning INF2810: Funksjonell Programmering Tilstand og verditilordning Erik Velldal Universitetet i Oslo 1. mars 2018 Forrige gang 2 Kode som trær 3 Ved evaluering oversettes kildekoden i et språk først til et

Detaljer

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Oppsummering og eksamensforberedelser Erik Velldal & Stephan Oepen Universitetet i Oslo 31. mai 2016 I dag Kort oppsummering Praktisk

Detaljer

Han Ola of Han Per: A Norwegian-American Comic Strip/En Norsk-amerikansk tegneserie (Skrifter. Serie B, LXIX)

Han Ola of Han Per: A Norwegian-American Comic Strip/En Norsk-amerikansk tegneserie (Skrifter. Serie B, LXIX) Han Ola of Han Per: A Norwegian-American Comic Strip/En Norsk-amerikansk tegneserie (Skrifter. Serie B, LXIX) Peter J. Rosendahl Click here if your download doesn"t start automatically Han Ola of Han Per:

Detaljer

5 E Lesson: Solving Monohybrid Punnett Squares with Coding

5 E Lesson: Solving Monohybrid Punnett Squares with Coding 5 E Lesson: Solving Monohybrid Punnett Squares with Coding Genetics Fill in the Brown colour Blank Options Hair texture A field of biology that studies heredity, or the passing of traits from parents to

Detaljer

UNIVERSITETET I OSLO ØKONOMISK INSTITUTT

UNIVERSITETET I OSLO ØKONOMISK INSTITUTT UNIVERSITETET I OSLO ØKONOMISK INSTITUTT Eksamen i: ECON320/420 Matematikk 2: Matematisk analyse og lineær algebra Exam: ECON320/420 Mathematics 2: Calculus and Linear Algebra Eksamensdag: Tirsdag 7. juni

Detaljer

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser INF2810: Funksjonell Programmering Oppsummering og eksamensforberedelser Erik Velldal & Stephan Oepen Universitetet i Oslo 31. mai 2016 I dag 2 Kort oppsummering Praktisk om eksamen Hvem vant konkurransen

Detaljer

Gir vi de resterende 2 oppgavene til én prosess vil alle sitte å vente på de to potensielt tidskrevende prosessene.

Gir vi de resterende 2 oppgavene til én prosess vil alle sitte å vente på de to potensielt tidskrevende prosessene. Figure over viser 5 arbeidsoppgaver som hver tar 0 miutter å utføre av e arbeider. (E oppgave ka ku utføres av é arbeider.) Hver pil i figure betyr at oppgave som blir pekt på ikke ka starte før oppgave

Detaljer

UNIVERSITETET I OSLO

UNIVERSITETET I OSLO Side 1 UNIVERSITETET I OSLO Det matematisk-naturvitenskapelige fakultet Eksamen i: INF2810 Eksamensdag: 7. juni Tid for eksamen: 14.30 Oppgavesettet er på 5 sider Vedlegg Relevante prosedyrer Tillatte

Detaljer

UNIVERSITETET I OSLO ØKONOMISK INSTITUTT

UNIVERSITETET I OSLO ØKONOMISK INSTITUTT UNIVERSITETET I OSLO ØKONOMISK INSTITUTT Eksamen i: ECON30/40 Matematikk : Matematisk analyse og lineær algebra Exam: ECON30/40 Mathematics : Calculus and Linear Algebra Eksamensdag: Tirsdag 0. desember

Detaljer

Par og Lister (først et par sider fra forrige uke) Par er byggestener for lister og trær og sammensatte datatyper.

Par og Lister (først et par sider fra forrige uke) Par er byggestener for lister og trær og sammensatte datatyper. Par og Lister (først et par sider fra forrige uke) Par er byggestener for lister og trær og sammensatte datatyper. Par kan representeres grafiske slik: Som vi ser kan vi bruke cons til å lage par hvis

Detaljer

IN2010: Algoritmer og Datastrukturer Series 2

IN2010: Algoritmer og Datastrukturer Series 2 Universitetet i Oslo Institutt for Informatikk S.M. Storleer, S. Kittilsen IN2010: Algoritmer og Datastrukturer Series 2 Tema: Grafteori 1 Publisert: 02. 09. 2019 Utvalgte løsningsforslag Oppgave 1 (Fra

Detaljer

INF2810: Funksjonell Programmering. Strømmer

INF2810: Funksjonell Programmering. Strømmer INF2810: Funksjonell Programmering Strømmer Stephan Oepen & Erik Velldal Universitetet i Oslo 12. april 2013 Tema 2 Forrige uke Litt mer i dybden om køer Eksperiment: live-programmering Tabeller som hierarkiske

Detaljer

KROPPEN LEDER STRØM. Sett en finger på hvert av kontaktpunktene på modellen. Da får du et lydsignal.

KROPPEN LEDER STRØM. Sett en finger på hvert av kontaktpunktene på modellen. Da får du et lydsignal. KROPPEN LEDER STRØM Sett en finger på hvert av kontaktpunktene på modellen. Da får du et lydsignal. Hva forteller dette signalet? Gå flere sammen. Ta hverandre i hendene, og la de to ytterste personene

Detaljer

INF2810: Funksjonell Programmering. Strømmer

INF2810: Funksjonell Programmering. Strømmer INF2810: Funksjonell Programmering Strømmer Stephan Oepen & Erik Velldal Universitetet i Oslo 12. april 2013 Tema 2 Forrige uke Litt mer i dybden om køer Eksperiment: live-programmering Tabeller som hierarkiske

Detaljer

UNIVERSITETET I OSLO ØKONOMISK INSTITUTT

UNIVERSITETET I OSLO ØKONOMISK INSTITUTT UNIVERSITETET I OSLO ØKONOMISK INSTITUTT Eksamen i: ECON320/420 Matematikk 2: Matematisk analyse og lineær algebra Exam: ECON320/420 Mathematics 2: Calculus and Linear Algebra Eksamensdag: Mandag 8. desember

Detaljer

1. Explain the language model, what are the weaknesses and strengths of this model?

1. Explain the language model, what are the weaknesses and strengths of this model? Øving 2 Task 1 Language Model 1. Explain the language model, what are the weaknesses and strengths of this model? En language model er en model som brukes til å forenkle spørringer etter ord i dokumenter.

Detaljer

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser

INF2810: Funksjonell Programmering. Oppsummering og eksamensforberedelser INF2810: Funksjonell programmering INF2810: Funksjonell Programmering Oppsummering og eksamensforberedelser Erik Velldal Universitetet i Oslo 28. mai 2015 I dag Kort oppsummering Praktisk om eksamen Hvem

Detaljer

INF2810: Funksjonell Programmering. Muterbare data

INF2810: Funksjonell Programmering. Muterbare data INF2810: Funksjonell Programmering Muterbare data Stephan Oepen Universitetet i Oslo 15. mars 2016 Agenda Forrige uke Prosedyrebasert objektorientering Lokale tilstandsvariabler Innkapsling + set! Eksempel:

Detaljer

Hjemmeeksamen 2 i INF3110/4110

Hjemmeeksamen 2 i INF3110/4110 Hjemmeeksamen 2 i INF3110/4110 Innleveringsfrist: onsdag 19. november kl. 1400 Innlevering Besvarelsen av oppgave 2,3,4 og 5 skal leveres skriftlig på papir i IFI-ekspedisjonen. Merk denne med navn, kurskode,

Detaljer

Memoisering, utsatt evaluering og strømmer

Memoisering, utsatt evaluering og strømmer Memoisering, utsatt evaluering og strømmer Først litt repetisjon: Utsatt evaluering Gitt (define (p x) (if test (x) something-else)) la E være et Scheme-uttrykk, og la L = (lambda () E). Da vil, ved kallet

Detaljer

Memoisering, utsatt evaluering og strømmer

Memoisering, utsatt evaluering og strømmer Memoisering, utsatt evaluering og strømmer Først litt repetisjon: Utsatt evaluering Gitt (define (p x) (if test (x) something-else)) la E være et Scheme-uttrykk, og la L = (lambda () E). Da vil, ved kallet

Detaljer

Eksamen i SLI230, vår 2003.

Eksamen i SLI230, vår 2003. Eksamen i SLI230, vår 2003. Oppgavesettet har 8 sider medregnet denne forsiden. Ingen hjelpemidler er tillatt. Vedlegg: To sider som inneholder en liste over primitiver fra scheme (og simply.scm) samt

Detaljer