מבוא מורחב למדעי המחשבSchemeבשפת

7תרגול

1

Outline

• More list examples

• Symbols

2

3

Triplets

• Constructor– (make-node value down next)

• Selectors– (value t)– (down t)– (next t)

4

skip

1 2 3 4 5 6 71 2 3 4 5 6

1 3 4 61 3 4 6

7

5

skip code

(define (skip lst)

(cond ((null? lst) lst)

((= (random 2) 1)

(make-node ________________

________________

________________ ))

(else (skip ________________ ))))

(value lst)

lst

(skip (next lst))

(next lst)

6

skip1

(define (skip1 lst) (make-node (value lst) lst (skip (next lst))))

Average length: (n+1)/2

Running Time: (n)

7

recursive-skip1

1 2 3 4 5 6 7

1 3 4 6

1 4

1

8

recursive-skip1 code

(define (recursive-skip1 lst)

(cond ((null? (next lst)) __________ )

(else ___________________________ )))

lst

(recursive-skip1 (skip1 lst))

9

make-star

g*(x) = number of times we need to apply g until g(g(g(…(g(x)…)))<=1

10

make-star

(define (make-star g)

(define (g* x)

(if (<= x 1)

0

(+ 1

(g* (g x)))))

g*

)

11

log

(log 4) ==> 2

(log 1) ==> 0

(log 5) ==> 3

(define log

(make-star ____________________ )(lambda (x) (/ x 2))

12

compose-stars

• Input: a list of functions– (f g h)

• Output: a composite function:– fgh*(x) := f*(g*(h*(x)))

• Idea:– Make a list of star functions– Compose them together

13

compose-stars

(define (compose-stars lst)

(accumulate

_______________________________

_______________________________

(map __________________________

__________________________ )))

compose

(lambda (x) x)

make-star

lst

Example: Horner Rule

14

Evaluating a polynomial in x at a given value of x

Algorithm :Horner's rule

Horner Rule: Cont’d

15

 (define (horner-eval x coeff-sequence) (accumulate (lambda (this-coeff higher-terms) (+ this-coeff (* x higher-terms))) 0 coeff-sequence))

P(x)=1+2*x+2*x*xP(3)=25

> (horner-eval 3 '(1 2 2))

The Special Formquote

16

quoteNumber: does nothing

'5=5

Name: creates a symbol

'a = (quote a) => a

Parenthesis: creates a list and recursively quotes

'(a b c) = (list 'a 'b 'c) =

= (list (quote a) (quote b) (quote c)) => (a b c)

17

quote'a => a

(symbol? 'a) => #t

(pair? 'a) => #f

''a => 'a

(symbol? ''a) => #f

(pair? ''a) => #t

(car ''a) => quote

(cdr ''a) => (a)

''''a => '''a

(car ''''a) => quote

(cdr ''''a) => (''a)18

19

The predicate eq?A primitive procedure that tests if the pointers representing the objects point to the same place.Based on two important facts:

• A symbol with a given name exists only once.

• Each application of cons creates a new pair, different from any other previously created.

Therefore:

(eq? ‘a ‘a) #t

But,

(eq? ‘(a b) ‘(a b)) #f

20

The predicate equal?A primitive procedure that tests if the pointers represent

identical objects

1. For symbols, eq? and equal? are equivalent

2. If two pointers are eq?, they are surely equal?

3. Two pointers may be equal? but not eq?

• (equal? ‘(a b) ‘(a b)) #t

• (equal? ‘((a b) c) ‘((a b) c)) #t

• (equal? ‘((a d) c) ‘((a b) c)) #f

eq? vs. equal? (symbols)

> (eq? ‘a ‘a)

> (equal? ‘a ‘a)

> (define x ‘a)

> (define y ‘a)

> (eq? x y)

> (equal? x y)

21

(eq? (list 1 2 3) (list 1 2 3))(equal? (list 1 2 3) (list 1 2 3))(equal? (list (list (list 1) 2) (list 1)) (list (list (list 1) 2) (list 1))) (define x (list 1 2 3))(define y (list 1 2 3))(eq? x y)(define z y)(eq? z y)(eq? x z)

eq? vs. equal? (symbols)

22

Example: Accumulate-n

23

Almost same as accumulateTakes third argument as “list of lists”

Example:> (accumulate-n + 0 ‘((1 2 3) (4 5 6) (7 8 9) (10 11 12)))(22 26 30)

Accumulate-n: Cont’d

24

(define (accumulate-n op init seqs) (if (null? (car seqs)) '() (cons (accumulate op init (map car seqs)) (accumulate-n op init (map cdr seqs)) )))

25

Example 1: memq

(define (memq item lst) (cond ((null? lst) #f) ((eq? item (car lst)) lst) (else (memq item (cdr lst)))))

(memq 'a '(b a b c)) =>

(memq 'a '((a b) b c)) =>

(memq 'a '((a b) b a (c a) d)) =>

(a b c)

#f

(a (c a) d)

If item does not appear in lst, returns false.Otherwise – returns the sublist beginning with item.

26

Example 2: rember

(define (rember item lst) (cond ((null? lst) '()) ((eq? item (car lst))(cdr lst)) (else (cons (car lst) (rember item (cdr lst))))))

(rember 'a '(d a b c a)) =>

(rember 'b '(a b c)) =>

(rember 'a '(b c d)) =>

(d b c a)(a c)

(b c d)

Removes the first occurrence of item from lst.

27

Example 3: rember*(define (rember* item lst) (cond ((null? lst) '()) ((atom? (car lst)) (if (eq? (car lst) item) (rember* item (cdr lst)) (cons (car lst) (rember* item (cdr lst))))) (else (cons (rember* item (car lst)) (rember* item (cdr lst))))))

(rember* 'a '(a b)) =>

(rember* 'a '(a (b a) c (a)) =>

(b)

((b) c ())

Removes all occurrences of item from lst, at all levels

Quine

28

((lambda (x) (list x (list 'quote x))) '(lambda (x) (list x (list 'quote x))))

A quine is a computer program that produces its own source code as its only output.

Split

> (define syms '(p l a y - i n - e u r o p e - o r - i n - s p a i n))

> (split syms ‘-)

((p l a y) (i n) (e u r o p e) (o r) (i n) (s p a i n))

29

Split

(define (split symbols sep)

(define (update sym word-lists)

(if (eq? sym sep)

(cons ___________________________________

___________________________________ )

(cons ___________________________________

___________________________________)))

(accumulate update (list null) symbols))

null

word-lists

(cons sym (car word-lists))

(cdr word-lists)

30

Replace

> (define syms '(p l a y - i n - e u r o p e - o r - i n - s p a i n))

> (replace ‘n ‘m syms)

(p l a y – i m – e u r o p e – o r – i m – s p a i m)

(define (replace from-sym to-sym symbols)

(map

))

(lambda (s) (if (eq? from-sym s) to-sym s))

symbols)

31

Accum-replace

> (accum-replace ‘((a e) (n m) (p a)) syms)

(p l a y – i n – e u r o p e – o r – i n – s p a i n)

(a l a y – i n – e u r o a e – o r – i n – s a a i n)

(a l a y – i m – e u r o a e – o r – i m – s a a i m)

(e l e y – i m – e u r o e e – o r – i m – s e e i m)

32

Accum-replace

(define (accum-replace from-to-list symbols)

(accumulate

(lambda(p syms)

( ________________________________ ))

____________________

from-to-list)) ))

replace (car p) (cadr p) syms

symbols

33

Extend-replace

> (extend-replace ‘((a e) (n m) (p a)) syms)

(p l a y – i n – e u r o p e – o r – i n – s p a i n)

(a l a y – i n – e u r o a e – o r – i n – s a a i n)

(a l a y – i m – e u r o a e – o r – i m – s a a i m)

(a l e y – i m – e u r o a e – o r – i m – s a e i m)

34

Extend-replace

(define (extend-replace from-to-list symbols)

(define (scan sym)

(let ((from-to (filter

_____________________________________

_____________________________________ )))

(if (null? from-to)

___________________________

___________________________)))

(map scan symbols))

(lambda (p) (eq? (car p) sym))

from-to-list

sym

(cadr (car from-to))

35