Lecture #7

מבוא מורחב1

Lecture #7

90-92, 2.1.3

99-103, 2.2.1

105-107, 2.2.1

107-112, 2.2.2


How can we implement pairs ?

(define (cons x y) (lambda (m) (cond ((= m 0) x) ((= m 1) y) (else (error "Argument not 0 or

1 -- CONS" m))))))

(define (cdr z) (z 1))

(define (car z) (z 0))


The pair constructed by (cons 6 9) is the procedure:

(lambda (m)

(cond ((= m 0) 6)

((= m 1) 9)

(else (error “Argument not 0 or 1 -- CONS” m))))

The pair (cons 6 9)


Lists

(list <x1> <x2> ... <xn>)

Same as

(cons <x1> (cons <x2> ( … (cons <xn> nil))))

<x1> <x2> <xn>

…


lists

A list is either

• ‘() (The empty list)• A pair whose cdr is a list.

Note that lists are closed under operations of

cons and cdr.


Null?

null? : anytype -> boolean

(null? <z>)

#t if <z> evaluates to empty list

#f otherwise

(null? 2) #f

(null? (list 1)) #f

(null? (cdr (list 1))) #t

(null? ‘()) #t


pair?

pair? : anytype -> boolean

(pair? <z>) #t if <z> evaluates to a pair

#f otherwise.

(pair? (cons 1 2)) #t

(pair? (cons 1 (cons 1 2))) #t

(pair? (list 1)) #t

(pair? ‘()) #f


atom?

atom? : anytype -> boolean

(define (atom? z) (and (not (pair? z)) (not (null? z))))

(define (sqrt x) (* x ))(atom? sqrt) #t


caddr

(define one-to-four (list 1 2 3 4))

one-to-four ==> (1 2 3 4)

(1 2 3 4) ==> error

(car one-to-four) ==>

(car (cdr one-to-four)) ==>

1

2

(cadr one-to-four) ==> 2

(caddr one-to-four) ==> 3


Common Pattern #1: cons’ing up a list

(enumerate-primes 2 5)(cons 2 (enumerate-primes (+ 1 2) 4)))(cons 2 (cons 3 (enumerate-primes 4 5)))(cons 2 (cons 3 (enumerate-primes 5 5)))(cons 2 (cons 3 (cons 5 (enumerate-primes 6 5))))(cons 2 (cons 3 (cons 5 ‘())))(list 2 3 5)

(define (enumerate-primes from to) (cond ((> from to) '()) ((prime? from) (cons from (enumerate-primes (+ 1 from) to))) (else (enumerate-primes (+ 1 from) to))))

2 3 5


Common Pattern #1: enumerate-squares

(enumerate-squares 2 4)(cons 4 (enumerate-squares 3 4)))(cons 4 (cons 9 (enumerate-squares 4 4)))(cons 4 (cons 9 (cons 16 (enumerate-squares 5 4))))(cons 4 (cons 9 (cons 16 ‘())))(list 4 9 16)

(define (enumerate-squares from to) (cond ((> from to) '()) (else (cons (square from) (enumerate-squares (+ 1 from) to)))))

4 9 16


Common Pattern #2: cdr’ing down a list

(define (length lst) (if (null? lst) 0 (+ 1 (length (cdr lst)))))

(length (enumerate-primes 1 1000)) 169(length (enumerate-primes 1001 2000)) 135(length (enumerate-primes 100001 101000)) 81(length (enumerate-primes 10000001 10001000)) 61

(length (list 1 2 3)) 3(length (enumerate-squares 1 100)) 100


Length – iterative version

(define (length lst)

(define (length-iter temp count)

(if (null? temp)

count

(length-iter (cdr temp) (+ 1 count))))

(length-iter lst 0))


Another example: cdr’ing down a list

(define (list-ref lst n) ; find n’th element (if (= n 1) (car lst) (list-ref (cdr lst) (- n 1))))

(list-ref (list 1 2 3) 1) 1(list-ref (list 1 2 3) 4) car: expects argument of type <pair>; given ()

(define list-of-primes (enumerate-primes 2 10000))(list-ref list-of-primes 57) 269

15

Append

(define (append list1 list2) (cond ((null? list1) list2) ; base (else (cons (car list1) ; recursion (append (cdr list1)list2)))))

(append (list 1 2) (list 3 4))(cons 1 (append (2) (3 4)))(cons 1 (cons 2 (append () (3 4))))(cons 1 (cons 2 (3 4)))(1 2 3 4)

Time complexity: T(n) = (n) car,cdr,cons operations.

16

Reverse

(reverse (list 1 2 3))(append (reverse (2 3)) (1))(append (append (reverse (3)) (2)) (1))(append (append (append (reverse ()) (3)) (2)) (1))(append (append (append () (3)) (2)) (1))(append (append (3) (2)) (1))(append (3 2) (1))(3 2 1)

(define (reverse lst)(cond ((null? lst) lst)(else (append (reverse (cdr lst)) (list (car lst)))))))

(reverse (list 1 2 3 4)) ==> (4 3 2 1)

Append: T(n) = c*n = (n) Reverse: T(n) = c*(n-1) + c*(n-2) … c*1 = (n2)


Square-list, double-list,

(define (square-list lst) (if (null? lst) ‘() (cons (square (car lst)) (square-list (cdr lst)))))

(define (double-list lst) (if (null? lst) ‘() (cons (* 2 (car lst)) (double-list (cdr lst)))))


High order procedures to handle lists: map

(define (map proc lst) (if (null? lst) ‘() (cons (proc (car lst)) (map proc (cdr lst)))))

(define (square-list lst) (map square lst))

(define (scale-list lst c) (map (lambda (x) (* c x)) lst))

(scale-list (list 1 2 3 5) 10) ==>(10 20 30 50)


Pick odd elements out of a list

(define (odd-elements lst) (cond ((null? lst) ‘()) ((odd? (car lst)) (cons (car lst) (odd-elements (cdr lst)))) (else (odd-elements (cdr lst)))))

(enumerate-squares 2 6) (4 9 16 25 36)(odd-elements (enumerate-squares 2 6)) (9 25)


Filtering a List (filter)

(define (filter pred lst) (cond ((null? lst) ‘()) ((pred (car lst)) (cons (car lst) (filter pred (cdr lst)))) (else (filter pred (cdr lst)))))

(define list-of-squares (enumerate-squares 1 10))

(filter odd? list-of-squares)(1 9 25 49 81)


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


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

eln init

op

eln-1 el1 ……..

opop

op...


Length and append as accumulation

(define (length lst) (accumulate (lambda (x y) (+ 1 y))) 0 lst))

(define (append lst1 lst2) (accumulate cons lst2 lst1)


XX XX

XX

XX

XX XX

XX

XX XX

XX

XX XX

XX

7

XX XX XX XX XX

XX XX XX XX XX

XX XX XX XX XX

XX XX XX XX XX

XX XX XX XX XX

XX XX XX XX XX

XX XX XX XX XX

XX XX XX XX XX

XX XX XX XX XX

XXXX X 2

Finding all the primes

XX XX XX

XX XX XX XX

XX XX XX

XX XX XX

XX XX XX XX

XX XX XX

XX XX XX

XX XX XX XX

XX XX XX

X X 3

100999897969594939291

90898887868584838281

80797877767574737271

60696867666564636261

60595857565554535251

50494847464544434241

40393837363534333231

30292827262524232221

20191817161514131211

1098765432

XX XX

XX XX

XX XX

XX XX

XX XX

XX XX

XX XX

XX XX

XX XX

XX 5


.. And here’s how to do it!

(define (sieve lst)

(if (null? lst)

‘()

(cons (car lst)

(sieve (filter

(lambda (x)

(not (divisible? x (car lst))))

(cdr lst))))))


Trees

2 4

6 8(define tree (list 2 (list 6 8) 4))

(length tree) 3

We can view a list of possibly other lists and atoms as a tree.

children or subtrees

2

6 8

4

root


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

28

countleaves – 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

1 0

1 0


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


Scale-tree

(define (scale-tree tree factor)

(cond ((null? tree) nil) ;base case

((leaf? tree) (* tree factor))

(else ;recursive case

(cons

(scale-tree (cdr tree) factor )))))

(scale-tree (car tree) factor)

31

Alternative scale-tree

• Strategy

• base case: scale of empty tree is empty tree

• base case: scale of a leaf is product

• otherwise: a tree is a list of subtrees and use 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))))

Documents

Lecture #7