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

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

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

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

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

6. 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 … )
(filter even? (map fib (integers-between 10 20)))
(map fib (filter even? (integers-between 10 20)))
מבוא מורחב

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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