Två fall: q Tom sekvens: () q Sekvens av element: (a b c) ; (sum-rec '(2 4 6)) = 12. q Första elementet uppfyller vissa villkor: (2 a b c)

Relevanta dokument
TDDC74 Programmering, abstraktion och modellering DUGGA 2

n Detta för att kunna koncentrera oss på n Tal: number? n Symboler: symbol? n Strängar: string? n Tecken: char? n Boolskt: boolean?

Dagens föreläsning Programmering i Lisp Fö 5

Universitetet i Linköping Institutionen för datavetenskap Anders Haraldsson 2

Rekursiva algoritmer sortering sökning mönstermatchning

TDDC74 Programmering: Abstraktion och modellering Tentamen, onsdag 9 juni 2016, kl 14 18

TDDC74 Programmering, abstraktion och modellering. Tentamen

TDDC74 Lab 02 Listor, sammansatta strukturer

TDDC74 Programmering: Abstraktion och modellering Datortenta , kl 14-18

TDDC74 Programmering: Abstraktion och modellering Tentamen, lördag 27 augusti 2016, kl 8 12

Signalflödesmodellen. Två (gamla) exempel: Kvadratera alla jämna löv.

TDDC74 Programmering: Abstraktion och modellering Dugga 2, kl 8 10, 5 mars 2015

TDDC74 Programmering, abstraktion och modellering. Tentamen

TDDC74 Programmering, abstraktion och modellering. Tentamen

Idag: Par och listor. Symboler. Symboler används för att uttrycka icke-numeriska data såsom namn, adress, bilregisternummer, boktitel, osv.

TDDC74 Programmering: Abstraktion och modellering Datortenta , kl 14-18

TDDC74 Programmering: Abstraktion och modellering Tenta, kl 14 18, 11 juni 2014

Idag: Par och listor. Scheme. DA2001 (Föreläsning 6) Datalogi 1 Hösten / 29

TDDC74 Programmering: Abstraktion och modellering Dugga 2, Tid: kl 08-10, Datum:

TDDC74 Programmering: Abstraktion och modellering Datortenta

TDDC74 Programmering, abstraktion och modellering. Tentamen

TDDC74 Programmering: Abstraktion och modellering Datortenta , kl 08-12

TDDC74 Programmering: Abstraktion och modellering Dugga 1, exempeldugga

Tentamen i. TDDC67 Funktionell programmering och Lisp

Symbolisk data. quote. (define a 1) (define b 2) (jacek johan david) (list a b)

Linjärt minne. Sammanhängande minne är ej flexibelt. Effektivt

TDDC74 Lab 04 Muterbara strukturer, omgivningar

TDDC74 Programmering, abstraktion och modellering DUGGA 2

Tentamen i. TDDA 69 Data och programstrukturer

Datalogi, grundkurs 1 Övningsuppgifter i Scheme. Serafim Dahl, Carina Edlund, m.fl.

TDDC74 Programmering: Abstraktion och modellering Datordugga 2 - exempel

TDDC74 Programmering: Abstraktion och modellering Tentamen, lördag 29 augusti 2015, kl 8 12

TDDC74 - Lektionsmaterial C

TDDC74 Programmering, abstraktion och modellering DUGGA 1

Föreläsning 9 Exempel

TDDC74 Programmering: Abstraktion och modellering Dugga 2, , kl 14-16

TDDC74 Programmering: Abstraktion och modellering Dugga 1, kl 14-16

TDDC74 Programmering: Abstraktion och modellering Dugga 2, kl 8 10, 3 mars 2016

Tillämpad Programmering (ID1218) :00-13:00

Föreläsning 9 Exempel. Intervallhalveringsmetoden. Intervallhalveringsmetoden... Intervallhalveringsmetoden...

Ändringsbar (mutable compound) data. TDDC74 Programmering: abstraktion och modellering. Sätta - samman listor kopiering. Hitta sista cons-cellen

TDDC74 Programmering, abstraktion och modellering DUGGA 3

Lösningsförslag. TDDC74 Programmering: Abstraktion och modellering. Dugga 3 (provkod TEN1), Tid: kl 14-16, Datum:

Våra enkla funktioner eller procedurer

Datalogi, grundkurs 1. Lösningsförslag till tentamen

TDDC74 Programmering: Abstraktion och modellering Dugga 2, , kl 17-19

Sökning och sortering. Sökning och sortering - definitioner. Sökning i oordnad lista. Sökning med vaktpost i oordnad lista

Sökning och sortering

Dagens föreläsning Programmering i Lisp Fö 7. Sammanfattning funktionell programmering Exempel på funktionella programspråk

Föreläsning 9 Innehåll

Idag: Dataabstraktion

TDDC74 Programmering: Abstraktion och modellering. Provkod TEN1, Tid: kl 14-18, , Kåra

TDDC74 PROGRAMMERING: ABSTRAKTION OCH MODELLERING VT 2017

Föreläsning Datastrukturer (DAT036)

Tabeller. Programkonstruktion. Moment 8 Om abstrakta datatyper och binära sökträd. Implementering av tabellen. Operationer på tabellen

Inlämningsuppgiften. Föreläsning 9 Innehåll. Träd. Datastrukturer i kursen

Institutionen för datavetenskap, DAT060, Laboration 2 2 För denna enkla simulerings skull kommer handen att representeras som ett par tal μ värdet på

Sökning i ordnad lista. Sökning och sortering. Sökning med vaktpost i oordnad lista

Datalogi, grundkurs 1

Programmeringsmetodik DV1 Programkonstruktion 1. Moment 8 Om abstrakta datatyper och binära sökträd

Imperativ programmering. Imperativ programmering konstruktioner i Lisp. Datastrukturer (kap ) arraystruktur poststruktur

FÖRELÄSNING 2, TDDC74, VT2018 BEGREPP PROBLEMLÖSNING MED HJÄLP AV FALLANALYS PROBLEMLÖSNING MED HJÄLP AV REKURSION

Programmering II (ID1019) :00-17:00

Lösningar Datastrukturer TDA

BEGREPP HITTILLS FÖRELÄSNING 2 SAMMANSATTA UTTRYCK - SCHEME DATORSPRÅK

LABORATION 1. Inledande Lisp - rekursion

Programmering II (ID1019) :00-12:00

729G74 IT och programmering, grundkurs. Tema 3. Föreläsning 2 Jody Foo,

Datastrukturer i kursen. Föreläsning 8 Innehåll. Träd rekursiv definition. Träd

Programmering II (ID1019)

Instruktioner - Datortentamen TDDD73 Funktionell och imperativ programmering i Python

Lära dig analysera större och mer komplicerade problem och formulera lösningar innan du implementerar.

Självbalanserande träd AVL-träd. Koffman & Wolfgang kapitel 9, avsnitt 1 2

TENTAMEN: Algoritmer och datastrukturer. Läs detta! Uppgifterna är inte avsiktligt ordnade efter svårighetsgrad.

Föreläsning 13. Träd

Obligatorisk uppgift 5

Datalogi, grundkurs 1. Lösningsförslag till tentamen

FÖRELÄSNING 1 PERSONAL TDDC74 PROGRAMMERING: ABSTRAKTION OCH MODELLERING VT 2017 SYFTE EXAMINATION ORGANISATION

Dagens föreläsning Programmering i Lisp. - Bindning av variabler (avs 14.6) fria variabler statisk/lexikalisk och dynamisk bindning

Hur man programmerar. TDDC66 Datorsystem och programmering Föreläsning 3. Peter Dalenius Institutionen för datavetenskap

I dag: Blockstruktur, omgivningar, problemlösning

Datalogi, grundkurs 1

Föreläsning 9 Innehåll

Procedurer och villkor. Rekursiva procedurer. Exempel: n-fakultet

Procedurer och villkor

Datastrukturer. föreläsning 10. Maps 1

Ett generellt träd är. Antingen det tomma trädet, eller en rekursiv struktur: rot /. \ /... \ t1... tn

Träd. Rot. Förgrening. Löv

Funktionell programmering DD1361

Föreläsning 9 Datastrukturer (DAT037)

TDDC74 Programmering: Abstraktion och modellering Dugga 3, kl 8 10, 7 april 2016

allt.cl Page 1 of 17 Date: torsdag 7 december 2006

Programmering II (ID1019) :00-13: hp

Förra gången: Primitiva data

Tentamen, Algoritmer och datastrukturer

Programkonstruktion och datastrukturer. Moment 9 Om högre ordningens funktioner. PKD 2010/11 moment 9 Sida 1 Uppdaterad

TDDC74 Programmering: Abstraktion och modellering Dugga 3, kl 14 16, 25 mars 2015

Dagens föreläsning. Diverse Common Lisp. Konstanter, parametrar, globala variabler

Dataabstraktion. TDDD73 Funktionell och impterativ programmering i Python Föreläsning 12. Peter Dalenius Institutionen för datavetenskap

Transkript:

Programmönster: # Listan som sekvens, Rekursiv process Enkel genomgång av sekvens (element på toppnivån i en lista)) TDDC60 Programmering: abstraktion och modellering Föreläsning 5 Rekursiva och iterativa programmeringsmönster för sekvenser Rekursiva mönster för binära träd och hierarkiska strukturer. Högre ordningens mönster. Sammanfattning rekursiva modeller. Metodik för att utveckla och verifiera rekursiva funktioner. Två fall: q Tom sekvens: () q Sekvens av element: (a b c) (DEFINE(FN SEQ) (IF (NULL? SEQ) <null-resultat> (<operation> (FIRST SEQ) (FN (REST SEQ))))) (define (sum-rec seq-rec); Summera talen i en lista (sekvens) 0 (+ (first seq) (sum-rec (rest seq))))) ; (sum-rec '(2 4 6)) = 2 Programmönster: # Listan som sekvens, Rekursiv process (define (increase-rec seq n) ; Öka alla elementen i en lista (sekvens) med n (cons (+ (first seq) n) (increase-rec (rest seq))))) ; (increase-rec '(3 5 7) 00) = (03 05 07) (define (my-append seq seq2) ; Sätt samman två listor (sekvenser) (if (null? seq) seq2 (cons (first seq) (my-append (rest seq) seq2)))) ; (my-append '( 2 3) '(a b c)) = ( 2 3 a b c) Programmönster: # Listan som sekvens, Iterativ process (DEFINE (FN SEQ) (DEFINE (ITER SEQ RESULT) (IF (NULL? SEQ) RESULT (ITER (REST SEQ) (<operation> (FIRST SEQ) RESULT)))) (ITER SEQ <start-result>)) (define (sum-iter seq) ; Summera talen (define (iter seq result) result (iter (rest seq) (+ result (first seq))))) (iter seq 0)) ; (sum-iter (2 4 6)) = 2 Programmönster: # Listan som sekvens, Iterativ process Observera att resultatet byggs upp framifrån av elementen i listan. Jämför med rekursiv process där vi bygger upp bakifrån. (define (increase-iter seq n) ; summera alla talen i en lista (sekvens) (define (iter seq res) res (iter (cdr seq) (put-last (+ (first seq) n) res)))) (iter seq )) (define (put-last e seq) (append seq (list e))) ; (increase-iter '(3 5 7) 00) = (03 05 07) Programmönster: #2 Som mönster # men särskild bearbetning av enskilda element Tre fall: q Tom sekvens: () q Första elementet uppfyller vissa villkor: (2 a b c) q Generella fallet: (a b c ) (DEFINE (FN SEQ) (COND ((NULL? SEQ) <null-result>) ((<condition> (FIRST SEQ)) <result>))... fler villkor... (ELSE (<operation> (FIRST SEQ) (FN (REST SEQ))))))

Programmönster #2: Särskild bearbetning av enskilda element. Rekursiv process (define (number-in-list? seq) ; Innehåller en lista ett tal (cond ((null? seq) #f) ((number?(first seq)) #t) (else (number-in-list? (rest seq))))) ; (number-in-list? '(a 3 b)) = #t ; (number-in-list? '(a b c)) = #f (define (rem-numbers seq) ; Tag bort alla tal från en lista (sekvens) (cond ((null? seq)) ((number? (first seq)) (rem-numbers (rest seq))) (else (cons (first seq) (rem-numbers (rest seq)))))) Programmönster #2: Särskild bearbetning av enskilda element. Rekursiv process (define (substitute seq old new) ; ersätt alla av ett givet element med ett nytt element (cond ((null? seq) ) ((eq? (first seq) old) (cons new (substitute (rest seq) old new))) (else (cons (first seq) (substitute (rest seq) old new)))))) ; Ersättt alla a med x ; (substitute '(a b c a d a) 'a 'x) = (x b c x d x) ; (rem-numbers '(a 2 b c 3)) = (a b c) Programmönster: #3 Listan innehåller element som i sin tur kan vara listor. Sekvenser. Hierarkiska strukturer. Tre Fall: q Tomma: () q Första element är inte en lista (atomärt): (a (b) c) q General case: ((a b) (b c) (d)) Ger en sekvenslösning. Brukar benämnas dubbelrekursion (car-cdr rekursion) Programmönster: #3 Listor med listor (define (rem-all-numbers seq) ; Tar bort alla tal på alla nivåer (cond ((null? seq) ) ((atom? (first seq)) (if (number? (first seq)) (rem-all-numbers (rest seq)) (cons (first seq) (rem-all-numbers (rest seq))))) (else (cons (rem-all-numbers (first seq)) (rem-all-numbers (rest seq)))))) ; Ersätt alla a mot x på alla nivåer (rem-all-numbers '(a (3 4) ((a 5 d) e))) = (a () ((a d) e)) (define (atom? obj) (not (list? obj))) Binärt träd. Trädet har noder och bågar. Toppen benämns rot och avslutas i löv. Kan skapas av cons-par: (cons (cons (cons 2) (cons 'a 'b)) 'x) = (((. 2). (a. b)). x) x Programmönster: #4 Binär trädstruktur. Representerat som punkterade par. Två fall: q Löv: a q Generellt fall, nod: (((a. b). (b. c)). d) Tre fall: q Tomt träd: () q Löv: a q Generellt fall, nod: (((a. b). (b. c)). d) 2 a b 2

(DEFINE (FN TREE) (COND ; ((EMPTY? TREE) <empty-result>);finns tomt träd? ((LEAF? TREE) <leaf-result>) (ELSE (<operation> (FN (LEFT TREE)) (FN (RIGHT TREE)))))) Med representation av trädet som punkterade par definieras primitiverna: (define (leaf? bt) (not (pair? bt))) (define left car) (define right cdr) (define (leaves bt) ; returnerar antalet löv (if (leaf? bt) (+ (leaves (left bt))) (leaves (right bt))))) (leaves '(((. 2). (a. b)). x) = 5 Med abstraktion kan trädet vara representerat på andra sätt. I stälet för ett punkterat par kan representionen vara en lista med två element, höger resp. vänster delträd. Huvudfunktionen blir samma. (define (leaf? bt) (not (pair? bt?))) (define left car) (define right cadr) (define (leaves bt) ; returnerar antalet löv (if (leaf? bt) (+ (leaves (left bt))) (leaves (right bt))))) (leaves '((( 2) (a b)) x)) = 5 Här representeras ett aritmetiskt uttryck som ett binärt träd. Operatorn lagras i noden. Bearbetningen av uttrycken sker med binär-träd mönstret. Ett aritmetiskt uttryck lagras som: löv - konstant nod - (operand- operator operand-2) 3 + 4 * (5 + 6) -> representeras (3 + (4 * (5 + 6))) Selektorer för att komma åt delarna från en nod, dvs vänster resp. höger operand och operatorn. (define oper- first) (define oper-2 third) (define operator second) (define (value expr) ; beräknar värdet av ett aritmetiskt uttryck (cond ((number? expr) expr) ((eq? (operator expr) '+) (+ (value (oper- expr)) (value (oper-2 expr)))) ((eq? (operator expr) '*) (* (value (oper- expr)) (value (oper-2 expr)))))) (value '(3 + (4 * (5 + 6)))) = 47 Programmönster: #5 Generella listor. Listor kan avslutas med punkterat par. Kan innehålla punkterad lista. Listan avslutas ej med tomma listan. (cons 'a (cons 'b 'c)) = (a. (b. c)) = (a b. c) Testas med pair?. (Äkta listor kan testas med list?) CAR och CDR används på sådana listor. Fyra fall: q Tomma listan: () q Icke-lista (atom): a q Första elementet är icke-lista (atomär): (a (b c) (d). e) q Generellt fall: ((a. b) (b c) (d). e) 3

Programmönster: #5 Generella listor. (define (add-one gen-list); Öka varje tal med. (cond ((null? gen-list) ) ((atom? gen-list) (if (number? gen-list) (+ gen-list) gen-list)) ((atom? (car gen-list)) (if (number? (car gen-list)) (cons (+ (car gen-list)) (add-one (cdr gen-list))) (cons (car gen-list) (add-one (cdr gen-list))))) (else (cons (add-one (car gen-list)) (add-one (cdr gen-list)))))) Högre ordningens funktioner för listor n Alla mönster kan omformas till högre ordningens funktioner/procedurer där operationer/funktioner, startvärde mm ges som parametrar. n Speciellt för listan (sekvensen) finns ofta många fördefinierade högra ordningens funktioner. (add-one '(a (b. 2) (c (3)). 4)) = (a 2 (b. 3) (c (4)). 5) Mönster # som högre ordningens funkiton (DEFINE (FN TREE) (if (LEAF? TREE) <leaf-result> (<operation> (FN (LEFT TREE)) (FN (RIGHT TREE))))) Mönster (define (bin-tree node-fn leaf-fn tree) (if (leaf? tree?) (leaf-fn tree) Högre ordningens funktion (node-op (bin-tree node-fn leaf-fn (left tree)) (bin-tree node-fn leaf-fn (right tree))))) Mönster # som högre ordningens funkiton (define (bin-tree node-fn leaf-fn tree) (if (leaf? tree) (leaf-fn tree) (node-fn (bin-tree node-fn leaf-fn (left tree)) (bin-tree node-fn leaf-fn (right tree))))) ; Skapa ett nytt träd där vänster och höger ; deltäd byter plats på alla nivåder (bin-tree (lambda (left right) (cons right left)) (lambda (leaf) leaf) '(((. 2). (a. b)). x) = (x. ((b. a). (2. ))) = (x (b. a) 2. ) Observera att Scheme skriver ut i första hand i listformat. Högre-ordningens procedurer för sekvenser. Exempel på funktioner från kursboken (avs 2.2 I SICP) Map gör något på varje element i en sekvens (define (map proc seq) (cons (proc (first seq)) (map proc (rest seq))))) ; öka varje element med 5 (map (lambda (e)( + e 5)) '(2 6 4)) = ( 2+5 6+5 4+5 ) = (7 9) Filter - ta ut vissa element från en lista (define (filter predicate seq) (cond ((null? seq) ) ((predicate (first seq)) (cons (first seq) (filter predicate (rest seq)))) (else (filter predicate (rest seq))))) ; Ta ut alla positiva talen (filter (lambda (x) (> x 0)) '(3-5 4 2-7)) = (3 4 2) 4

Enumerate / generate - skapa successiva element i en lista (enumerate 3 0) = (3 4 5 6 7 8 9 0) Skapa en lista med nr element där nästföljande element beräknas fram av föregående. (define (my-generate next-proc start nr) (if (= nr 0) (cons start (my-generate next-proc (next-proc start) (- nr ))))) Accumulate ( kallas även Reduce) (define (accumulate op initial sequence) (if (null? sequence) initial (op (first sequence) (accumulate op initial (rest sequence))))) (accumulate + 0 '(2 4 6)) = (+ 2 (+ 4 (+ 6 0))) = 2 accumulate list '( 2 3)) = = (list (list 2 (list 3 ))) = ( (2 (3 ()))) (my-generate (lambda (n) (* n n)) 2 5) = (2 4 6 256 65536) Problem kan nu lösas genom lämplig kombination av sådana funktioner Vem har mest lön av anställda med lön under 0.000 med anställningsnummer från 50 till 00? (accumulate max 0 (filter (lambda (salary) (< salary 0000)) (map fetch-salary (enumerate 50 00)))) Antag det finns en funktion fetch-salary som givet ett anställningsnummer ger lönen. 5