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

2. מבוא מורחב 2 Shall we have some real fun.. Lets write a procedure scramble.. (scramble (list 0 1 0 2)) ==> (0 0 0 1) (scramble (list 0 0 0 2 3 1 0 0 8 1)) ==> (0 0 0 0 0 3 0 0 0 8) (scramble (list 0 1 2 3 4 5 6 7)) ==> (0 0 0 0 0 0 0 0) (scramble (list 0 1 2 1 2 1 2 1 2)) ==> ( 0 0 0 2 2 2 2 2 2)

3. מבוא מורחב 3 Ok ok Each number in the argument is treated as backword index from its own position to a point earlier in the tup. The result at each position is found by counting backward from the current position according to this index ==> No number can be greater than its index

4. מבוא מורחב 4 tup = (0 1 2 1) rev-pre = () (cons 0 …. tup = (1 2 1) rev-pre = (0) (cons 0 (cons 0 tup = (2 1) rev-pre = (1 0) (cons 0 (cons 0 (cons 0 tup = (1) rev-pre = (2 1 0) (cons 0 (cons 0 (cons 0 (cons 2 tup = ( ) rev-pre = (1 2 1 0) (cons 0 (cons 0 (cons 0 (cons 2 ()))))

5. מבוא מורחב 5 list-ref scramble-i (define (scramble-i tup rev-pre) (if (null? tup) '() (cons ( (cons (car tup) rev-pre) (car tup)) ( (cdr tup) (cons (car tup) rev-pre))))) (define (scramble tup) (scramble-b tup '()))

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

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

8. מבוא מורחב 8 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)

9. מבוא מורחב 9 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)

10. מבוא מורחב 10 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)))

11. מבוא מורחב 11 Accumulating Results (accumulate) (define (add-up lst) (if (null? lst) 0 (+ (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)))))

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

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

14. מבוא מורחב 14 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)

15. מבוא מורחב 15 What did we gain ? U sing 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))))

16. מבוא מורחב 16 Finding all the primes

17. מבוא מורחב 17.. 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)

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

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

20. מבוא מורחב 20 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)))

21. מבוא מורחב 21 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

22. 22 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) ) + (cl (5 7))(cl (2)) + (cl 2) (cl nil) + (cl 5) (cl (7)) + (cl 7) (cl nil) 1 1 10 1 0

23. מבוא מורחב 23 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

24. 24 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))))

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

26. מבוא מורחב 26 (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))

27. 27 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

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

29. 29 Implementation (define (sum-odd-squares tree) (accumulate + 0 (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))))))

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

31. מבוא מורחב 31 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. ())))

32. 32 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)

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