1 / 27

6.001 SICP – September ?

6.001 SICP – September ?. 6001-Introduction Trevor Darrell trevor@csail.mit.edu 32-D512 6.001 web page: http://sicp.csail.mit.edu/ section web page: http://www.csail.mit.edu/~trevor/6001/ Abstractions Pairs and lists Common list operations. Procedural abstraction example: sqrt.

paniz
Télécharger la présentation

6.001 SICP – September ?

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 6.001 SICP – September ? 6001-Introduction Trevor Darrell trevor@csail.mit.edu 32-D512 6.001 web page: http://sicp.csail.mit.edu/ section web page: http://www.csail.mit.edu/~trevor/6001/ • Abstractions • Pairs and lists • Common list operations 6.001 SICP

  2. Procedural abstraction example: sqrt To find an approximation of square root of x: • Make a guess G • Improve the guess by averaging G and x/G • Keep improving the guess until it is good enough (define try (lambda (guess x) (if (good-enuf? guess x) guess (try (improve guess x) x)))) (define improve (lambda (guess x) (average guess (/ x guess)))) (define average (lambda (a b) (/ (+ a b) 2))) (define good-enuf? (lambda (guess x) (< (abs (- (square guess) x)) 0.001))) (define sqrt (lambda (x) (try 1 x))) 6.001 SICP

  3. average try improve Good-enuf? sqrt The universe of procedures for sqrt 6.001 SICP

  4. sqrt good-enuf? x: number improve : number sqrt-iter sqrt - Block Structure (define sqrt (lambda (x) (define good-enuf? (lambda (guess) (< (abs (- (square guess) x)) 0.001))) (define improve (lambda (guess) (average guess (/ x guess)))) (define sqrt-iter (lambda (guess) (if (good-enuf? guess) guess (sqrt-iter (improve guess))))) (sqrt-iter 1.0)) ) 6.001 SICP

  5. Pairs (cons cells) • (cons <x-exp> <y-exp>) ==> <P> ;type: x, x  Pair • Where <x-exp> evaluates to a value <x-val>, and <y-exp> evaluates to a value <y-val> • Returns a pair<P> whose car-part is <x-val> and whose cdr-part is <y-val> • (car <P>) ==> <x-val> ;type: Pairtype of car part • Returns the car-part of the pair <P> • (cdr <P>) ==> <y-val> ;type: Pairtype of cdr part • Returns the cdr-part of the pair <P> 6.001 SICP

  6. <el2> <el1> Pair - Box and pointer diagram (define p (cons <el1> <el2>)) p (car p) (cdr p) 6.001 SICP

  7. … <el1> <el2> <eln> Lists - Box and pointer diagram • (cons <el1> (cons <el2> nil)) • (list <el1> <el2> ... <eln>) <el1> <el2> 6.001 SICP

  8. Printed representation (define x (list 1 2)) (define y (list (list 1 2) (list 1 2)) (define z (list x x)) X == (1 2) Y == ((1 2)(1 2)) Z == ((1 2)(1 2)) 6.001 SICP

  9. Cons, car, cdr (define thing (cons (cons 1 nil) (cons 2 (cons 3 nil)))) thing ==> ((1) 2 3) (cons 1 nil) ==> (1) (cons 1 (cons 2 nil)) ==> (1 2) (car thing) ==> (1) (cdr thing) ==> (2 3) (car (car thing)) ==> 1 (car (cdr (cdr thing))) ==> 3 6.001 SICP

  10. List drill (car (cons (+ 1 2) (- 3 4))) ==> 3 (cdr 6) ==> error (cdr (car (cons (cons 1 2) (cons 3 4)))) 2 (pair? #t) ==> #f (pair? (car (cons 1 2))) ==> #f (pair? (cons (+ 1 2) (car (cons (3 4))))) ==> #t 6.001 SICP

  11. Length of a list (define (length lst) (if (null? lst) 0 (+ 1 (length (cdr lst)))) 6.001 SICP

  12. cdr’ing down a list (define (list-ref lst n) (if (= n 0) (car lst) (list-ref (cdr lst) (- n 1)))) 6.001 SICP

  13. More list drill x => (()) y => (1 2 3) z => (1 (2 3) ((4))) w => (1 2 3 4 5) (length x) (length y) (length z) (list-ref z 2) (append x y) (cons x y) 6.001 SICP

  14. More list drill x => (()) y => (1 2 3) z => (1 (2 3) ((4))) w => (1 2 3 4 5) (length x) 1 (length y) 3 (length z) 3 (list-ref z 2) ((4)) (append x y) (() 1 2 3) (cons x y) ((()) 1 2 3) 6.001 SICP

  15. Orders of Growth What is the order of growth of last-k ? (define (last-k k lst) (if (= (length lst) k) lst (last-k k (cdr lst)))) 6.001 SICP

  16. Orders of Growth What is the order of growth of last-k ? (define (last-k k lst) (if (= (length lst) k) lst (last-k k (cdr lst)))) Q( n2 ) 6.001 SICP

  17. Writing some procedures The procedure copy-some that copies the first n elements of a list (copy-some 3 (list 1 2 3 4 5)) ==> (1 2 3) (define (copy-some n list) ) 6.001 SICP

  18. Writing some procedures The procedure copy-some that copies the first n elements of a list (copy-some 3 (list 1 2 3 4 5)) ==> (1 2 3) (define (copy-some n list) (if (= n 0) nil (cons (car lst) (copy-some (- n 1) (cdr lst)))) ) 6.001 SICP

  19. Writing some procedures (repeat x m) returns a list containing the value x repeated m times.  For example: (repeat 5 3) => (5 5 5) (repeat (list 1 2) 2) => ((1 2) (1 2)) 6.001 SICP

  20. Writing some procedures Recursive solution:(define (repeat x m) (if (= m 0) nil (cons x (repeat x (- m 1)))))time Θ(m)space Θ(m)Iterative solution:(define (repeat x m) (define (helper i answer) (if (> i m) answer (helper (+ 1 i) (cons x answer)))) (helper 0 nil))time Θ(m)space Θ(1) 6.001 SICP

  21. Writing some procedures (append lst1 lst2) appends lst2 to the end of lst1.  E.g.: (append (list 0 1 2) (list 3 4)) => (0 1 2 3 4) (append nil (list 5 6)) => (5 6) 6.001 SICP

  22. Writing some procedures Recursive solution:(define (append lst1 lst2) (if (null? lst) lst2 (cons (car lst1) (append (cdr lst1) lst2)))) time Θ(n), space Θ(n) where n=(length lst1)Notice that only lst1 affects the time and space growth.  Why doesn't lst2 matter? 6.001 SICP

  23. Writing some procedures (reverse lst) reverses lst.  E.g.: (reverse (list 0 1 2)) => (2 1 0) (reverse (list (list 3 5) (list 2 4))) => ((2 4) (3 5)) 6.001 SICP

  24. Writing some procedures Recursive solution:(define (reverse lst) (if (null? lst) nil (append (reverse (cdr lst)) (list (car l)))))time Θ(n^2), since append runs in linear time (Θ(m) where m=(length answer)), each successive call to append takes more and more time: 1 + 2 + 3 + ... + n = Θ(n^2). space Θ(n), where n=(length lst)Iterative solution:(define (reverse lst) (define (helper rest answer) (if (null? rest) answer (helper (cdr rest) (cons (car rest) answer))))) (helper lst nil))time Θ(n^2), space Θ(1), where n=(length lst) 6.001 SICP

  25. Writing some procedures (num-leaves tree) returns the number of leaves in a tree, where a leaf is anything that isn't a list (number, string, boolean, procedure). E.g.: (num-leaves (list 0 1 (list 3 5) (list 2 (list 4)))) => 6 (num-leaves (list (list (list (list nil))))) => 0 6.001 SICP

  26. Writing some procedures (define (num-leaves tree) (cond ((null? tree) 0) ((pair? tree) (+ (num-leaves (car tree)) (num-leaves (cdr tree))) (else 1))) time Θ(n), space Θ(d), where n is the number of pairs in the tree, and d is the depth of the tree. 6.001 SICP

  27. Remember… • calendar… 6.001 SICP

More Related