Lecture #8 מבוא מורחב

Extracting common patterns: High order procedures to handle lists מבוא מורחב

Transforming a List (map) (define (square-list lst) (if (null? lst) nil (cons (square (car lst)) (square-list (cdr lst))))) (define (square-list lst) (map square lst)) (define (double-list lst) (map (lambda (x) (* 2 x)) lst)) (define (double-list lst) (if (null? lst) nil (cons (* 2 (car lst)) (double-list (cdr lst))))) (define (map proc lst) (if (null? lst) nil (cons (proc (car lst)) (map proc (cdr lst))))) define (scale-list lst f) (map (lambda (x) (* f x)) lst)) (scale-list 1-to-4 10) ==> (10 20 30 40) מבוא מורחב

Pick odd elements out of a list (define (odds lst) (cond ((null? lst) nil) ((odd? (car lst)) (cons (car lst) (odds (cdr lst)))) (else (odds (cdr lst))))) (odds 1-to-4) ==> (1 3) מבוא מורחב

Filtering a List (filter) (define (filter pred lst) (cond ((null? lst) nil) ((pred (car lst)) (cons (car lst) (filter pred (cdr lst)))) (else (filter pred (cdr lst))))) (filter odd? 1-to-4) ==> (1 3) (filter even? 1-to-4) ==> (2 4) מבוא מורחב

More examples In tirgul: (define (fib n) (cond ((= n 0) 0) ((= n 1) 1) (else (+ (fib (- n 1)) (fib (- n 2)))))) (map fib (integers-between 10 20)) ==> (55 89 …. 6765) (filter even? (map fib (integers-between 10 20))) (map fib (filter even? (integers-between 10 20))) מבוא מורחב

Accumulating Results (accumulate) (define (add-up lst) (if (null? lst) (+ (car lst) (add-up (cdr lst))))) (define (mult-all lst) (if (null? lst) 1 (* (car lst) (mult-all (cdr lst))))) (define (accumulate op init lst) (if (null? lst) init (op (car lst) (accumulate op init (cdr lst))))) מבוא מורחב

Accumulating (cont.) el1 eln-1 eln init …….. op ... (define (accumulate op init lst) (if (null? lst) init (op (car lst) (accumulate op init (cdr lst))))) eln init op eln-1 el1 …….. ... (define (add-up lst) (accumulate + 0 lst)) מבוא מורחב

Length as accumulation (define (length lst) (if (null? lst) (+ 1 (length (cdr lst))))) (define (accumulate op init lst) init (op (car lst) (accumulate op init (cdr lst))))) (define (length lst) (accumulate (lambda (x y) (+ 1 y))) lst)) מבוא מורחב

Append as accumulation (define (append list1 list2) (if (null? list1) list2 (cons (car list1) (append (cdr list1) list2)))) (define (accumulate op init lst) (if (null? lst) init (op (car lst) (accumulate op init (cdr lst))))) Rewrite append as an accumulation (define (append lst1 lst2) (accumulate cons lst2 lst1) מבוא מורחב

What did we gain ? (define (easy lo hi) (accumulate * 1 Using our tools: (define (easy lo hi) (accumulate * 1 (map fib (filter even? (integers-between lo hi))))) Without: (define (hard lo hi) (cond ((> lo hi) 1) ((even? lo) (* (fib lo) (hard (+lo 1) hi))) (else (hard (+ lo 1) hi)))) מבוא מורחב

Finding all the primes 100 99 98 97 96 95 94 93 92 91 90 89 88 87 86 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 60 69 68 67 66 65 64 63 62 61 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 XX X 3 XX 7 XX X 2 XX 5 מבוא מורחב

.. And here’s how to do it! (define (sieve lst) (if (null? lst) nil (cons (car lst) (sieve (filter (lambda (x) (not (divisible? x (car lst)))) (cdr lst)))))) (sieve (integers-between 2 420)) (2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101 103 107 109 113 127 131 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397 401 409 419) מבוא מורחב

View a list as a tree מבוא מורחב

Trees (define tree (list 2 (list 6 8) 4)) We can view a list of possibly other lists and atoms as a tree. 2 6 8 4 root children or subtrees (length tree) ==> (countleaves tree) ==> 3 4 מבוא מורחב

countleaves Strategy base case: count of an empty tree is 0 base case: count of a leaf is 1 recursive strategy: the count of a tree is the sum of the countleaves of each child in the tree. Implementation: (define (countleaves tree) (cond ((null? tree) 0) ;base case ((leaf? tree) 1) ;base case (else ;recursive case (+ (countleaves (car tree)) (countleaves (cdr tree)))))) (define (leaf? x) (not (pair? x))) מבוא מורחב

countleaves and substitution model – pg. 2 (define (countleaves tree) (cond ((null? tree) 0) ;base case ((leaf? tree) 1) ;base case (else ;recursive case (+ (countleaves (car tree)) (countleaves (cdr tree)))))) (define (leaf? x) (not (pair? x))) Example #2 (countleaves (list 5 7)) (countleaves ) (countleaves (5 7) ) (+ (countleaves 5) (countleaves (7) )) (+ 1 (+ (countleaves 7) (countleaves nil))) (+ 1 (+ 1 0)) ==> 2 7 5 מבוא מורחב

countleaves – bigger example (define my-tree (list 4 (list 5 7) 2)) (countleaves my-tree) (countleaves (4 (5 7) 2) ) (+ (countleaves 4) (countleaves ((5 7) 2) )) ==> 4 4 2 5 7 my-tree (cl (4 (5 7) 2)) + (cl 4) (cl ((5 7) 2) ) 1 + (cl (5 7)) (cl (2)) + (cl 5) (cl (7)) + (cl 2) (cl nil) + (cl 7) (cl nil) 1 1 1

Your Turn: scale-tree Goal: given a tree, produce a new tree with all the leaves scaled Strategy base case: scale of empty tree is empty tree base case: scale of a leaf is product otherwise, recursive strategy: build a new tree from a scaled version of the first child and a scaled version of the rest of children Implementation: (define (scale-tree tree factor) (cond ((null? tree) nil) ;base case ((leaf? tree) (* tree factor)) (else ;recursive case (cons (scale-tree (cdr tree) ))))) (scale-tree (car tree) factor) factor מבוא מורחב

Alternative scale-tree Strategy base case: scale of empty tree is empty tree base case: scale of a leaf is product otherwise: build a new tree from a scaled version of the children recognize that a tree is a list of subtrees and use a list oriented HOP! Alternative Implementation using map: (define (scale-tree tree factor) (cond ((null? tree) nil) ((leaf? tree) (* tree factor)) (else ;it’s a list of subtrees (map (lambda (child) (scale-tree child factor)) tree))))

Lists as interfaces מבוא מורחב

(define (sum-odd-squares tree) (cond ((null? tree) 0) ((leaf? tree) (if (odd? tree) (square tree) 0)) (else (+ (sum-odd-squares (car tree)) (sum-odd-squares (cdr tree)))))) (define (even-fibs n) (define (next k) (if (< k n) nil (let ((f (fib k))) (if (even? f) (cons f (next (+ k 1))) (next (+ k 1)))))) (next 0)) מבוא מורחב

Sum-odd-squares enumerates the leaves of a tree filters them, selecting the odd ones squares each of the selected ones accumulate the results using + Even-fibs enumerates the integers from 0 to n computes the Fibonacci number for each integer filters them selecting the even ones accumulated the results using cons

On horizontal arrows flow lists of numbers (interface) sum-odd-squares enumerate leaves filter map accumulate tree odd? square + even-fibs integers between map filter accumulate 0, n fib even? cons nil On horizontal arrows flow lists of numbers (interface) מבוא מורחב

Implementation (define (sum-odd-squares tree) (accumulate + (map square (filter odd? (enumerate-tree tree))))) (define (even-fibs n) (accumulate cons nil (filter even? (map fib (integers-between 0 n))))) (define (enumerate-tree tree) (cond ((null? tree) nil) ((leaf? tree) (list tree)) (else (append (enumerate-tree (car tree)) (enumerate-tree (cdr tree))))))

How does the interpreter prints lists and pairs ?? מבוא מורחב

First version, using dot notation (define (print-list-structure x) (define (print-contents x) (print-list-structure (car x)) (display " . ") (print-list-structure (cdr x))) (cond ((null? x) (display "()")) ((atom? x) (display x)) (else (display "(") (print-contents x) (display ")")))) (p-l-s (list 1 2 3)) ==> (1 . (2 . (3 . ()))) מבוא מורחב

Second version, try to identify lists (define (print-list-structure x) (define (print-contents x) (print-list-structure (car x)) (cond ((null? (cdr x)) nil) ((atom? (cdr x)) (display " . ") (print-list-structure (cdr x))) (else (display " ") (print-contents (cdr x))))) (cond ((null? x) (display "()")) ((atom? x) (display x)) (else (display "(") (print-contents x) (display ")")))) (p-l-s (list 1 2 3)) ==> (1 2 3)

More examples How to create the following output ? ( 1 2 . 3) (cons 1 (cons 2 3)) (1. 2 3) cannot מבוא מורחב