1. 6001 structure & interpretation of computer programs recitation 12/ november 4, 1997

2. topics mutable data structures
finish circular buffer example from last time
sample quiz problems
patterns, representations, tree search, streams
2/24/2019 daniel jackson

3. circular buffer (from last time)
model
always contains at least one element
values inserted to right of bar
values removed from right of bar
basic operations
make-circular-buffer : T –> CB
insert! : CB x T –> undefined
remove! : CB –> T
rotate-left! : CB –> undefined
rotate-right! : CB –> undefined
size : CB –> int
implementation hints
use only a singly-linked list
all ops are 0(1) time except for rotate-right! and size 1 6 2 5 4 3
2/24/2019 daniel jackson

4. implementation notes represent each entry as a cons cell
represent buffer as a cons cell whose car (cdr) is the cell to the left (right) of the bar
code
(define (make-cb v)
(let ((cell (cons v nil)))
(set-cdr! cell cell)
(cons cell cell)))
(define (insert! b v)
(let ((new-cell (cons v (cdr b))))
(set-cdr! (car b) new-cell)
(set-cdr! b new-cell)))
(define (remove! b)
(let ((old-cell (cdr b)))
(set-cdr! (car b) (cdr old-cell))
(set-cdr! b (cdr old-cell))
(car old-cell)))
2/24/2019 daniel jackson

5. implementation, ctd (define (size b) (define (count cell)
(if (eq? (car b) cell) 1
(inc (count (cdr cell)))))
(count (cdr b)))
; a hidden operation: (prev c) is the cell that precedes c
(define (prev c)
(define (follow current)
(let ((next (cdr current)))
(if (eq? c next)
current
(follow next))))
2/24/2019 daniel jackson

6. implementation, ctd (define (rotate-left! b) (set-car! b (cdr b))
(set-cdr! b (cddr b)))
(define (rotate-right! b)
(set-cdr! b (car b))
(set-car! b (prev (car b))))
2/24/2019 daniel jackson

7. sample problems: pattern matching (1)
Write a simplified version of (match pat dat) which takes
iin two args, both lists, representing the pattern & the datum.
The pattern has ?, ?variable & symbols. The datum has symbols.
It returns #f if there is no dictionary or it returns the
appropriate dictionary.
You can assume you have a procedure
(insert var val d) that returns a new dictionary obtainined by adding
the pair (var, val) to d, unless var is already there, in which case it
returns d if (var, val) is present and #f otherwise.
You can also assume that you have primitive procedures var?, anon-var?
that take a symbol and return true if the symbol is a variable, anonymous
variable
examples
(match '(? ?a b c ?d) '(hi there b c hello)) ==> ((?a there) (?d hello))
(match '(? ?a b c ?d) '(hi there b bad hello))==> #f
2/24/2019 daniel jackson

8. sample problems: pattern matching (2)
solution
(define (match pat dat) (cond ((not (eq? (length pat) (length dat))) #f)
((null? pat) ‘()) (let ((d (match (cdr pat) (cdr dat)))) (if (not d) d (cond ((var? (car pat)) (insert (car pat) (car dat) d)) ((anon-var? (car pat)) d) ((eq? (car pat) (car dat)) d) (else #f))))))
2/24/2019 daniel jackson

9. sample problems: pattern matching (3)
Write a simplified version of (instantiate temp dict)
which takes in two args, a template, which is a list of
?variables & symbols and dict which is a dictionary that
better have all the ?variables mentioned in the template.
It returns the template with the variables substituted
appropriately.
example
(instantiate '(this ?is a ?test) '((?is hi) (?test hello) (?other ignored)))
==> (this hi a hello)
solution
(define (instantiate temp dict) (define (lookup v) (cadr (assq v dict))) (map lookup temp))
2/24/2019 daniel jackson

10. sample problems: mutable bag
Design a Data Structure for....
& implement (or provide a sketch of how it works) the following functions:
Represent a mutable bag of elements. A bag is like a set with duplicates.
Create empty bag - O(1)
add element to bag - O(n) where n is number of distinct elements in bag
return total # of elements - O(n)
return # of distinct elements - O(n)
delete an element - O(n)
determine how many occurences of a particular element are in the bag - O(n)
After you have something that works with those time bounds,
see if you can improve (by changing slightly the data structure)
the time bounds for return total # of elements & return
# of distinct elements to O(1)
Can you think of other useful operations on the bag?
2/24/2019 daniel jackson

11. sample problem: tree search
a tree consists of a key, a value and a list of subtrees
write a search procedure that takes a tree and a key and returns a list of all values associated with the key
assume you have procedures empty?, key, value, next where (next t) returns the subtrees of t
code
(define (search t k) (define (dfs trees) (if (null? trees)
nil (let ((t1 (car trees))) (if (eq? (key t1) k) (cons (val t1) (dfs (append (next t1) (cdr trees)))) (dfs (append (next t1) (cdr trees)))))))
(dfs (list t)))
2/24/2019 daniel jackson

12. sample problem: streams (1)
what does map-stream do?
what is its type?
implement it using the primitives car-stream, cdr-stream, cons-stream
solution
map-stream : (t1 -> t2) x stream(t1) –> stream(t2)
(define (map-stream p s) (cons-stream (p (car-stream s)) (map-stream p (cdr-stream s))))
2/24/2019 daniel jackson

13. sample problem: streams (2)
take the tree from before
define a procedure that converts a tree to a stream
containing key/value pairs in depth first order.
use this to implement depth-frst search
code
(define (streamify t k) (define (dfs trees) (if (null? trees)
the-empty-stream
(let ((t1 (car trees))) (cons-stream (cons (key t1) (val t1)) (dfs (append (next t1) (cdr trees))))))) (dfs (list t)))
(define (search t k) (filter-stream (lambda (e) (eq? (key e) k)) (streamify t)))
2/24/2019 daniel jackson

14. sample problem: procedures with state
write a procedure that takes a procedure p of one argument
and returns another procedure, that behaves exactly like p
except when presented with the argument ‘how-many,
which causes it to return the number of times p has been called.
example
(define sc (counter square))
(sc 3) ==> 9
(sc 4) ==> 16
(sc ‘how-many) ==> 2
solution
(define (counter p) (let ((ct 0)) (lambda (i) (if (eq? i ‘how-many) ct (begin (set! ct (inc ct)) (p i))))))
2/24/2019 daniel jackson