The HTML for this page has been automatically generated by parsing the loosely formatted source code & comments included in my solutions repository (https://github.com/zv/SICP-guile), if you encounter any unformatted solutions, you think you've spotted an error or you have something you'd like to share about the exercises, don't hesitate to leave a comment below (or a pull request on the source repo).

## Exercises Chapter 3

### Exercise 3.1

An accumulator is a procedure that is called repeatedly with a single numeric
argument and accumulates its arguments into a sum. Each time it is called, it
returns the currently accumulated sum. Write a procedure make-accumulator that
generates accumulators, each maintaining an independent sum. The input to
make-accumulator should specify the initial value of the sum;

(define A (make-accumulator 5))

```(define (make-accumulator x)
(lambda (n)
(+ x n)))
```

### Exercise 3.2

In software-testing applications, it is useful to be able to count
the number of times a given procedure is called during the course of a
computation. Write a procedure make-monitored that takes as input a procedure,
f, that itself takes one input. The result returned by make-monitored is a third
procedure, say mf, that keeps track of the number of times it has been called by
maintaining an internal counter. If the input to mf is the special symbol
how-many-calls?, then mf returns the value of the counter. If the input is the
special symbol reset-count, then mf resets the counter to zero. For any other
input, mf returns the result of calling f on that input and increments the
counter. For instance, we could make a monitored version of the sqrt procedure:

```(define (make-monitored f)
(define calls 0)
(lambda (n)
(if (eq? n 'how-many-calls?)
calls
(begin
(set! calls (inc calls))
(f n)))))
```

#### Exercise 3.3

Modify the make-account procedure so that it creates password-protected
accounts. That is, make-account should take a symbol as an additional argument,
as in

```(define 3.3/acc (make-account 100 'secret-password))
(define (3.3/make-account acct# passwd)
(define (withdraw amount)
(if (>= balance amount)
(begin (set! balance
(- balance amount))
balance)
"Insufficient funds"))
(define (deposit amount)
(set! balance (+ balance amount))
balance)
(define (dispatch m)
(cond ((eq? m 'withdraw) withdraw)
((eq? m 'deposit) deposit)
(else (error "Unknown request:
MAKE-ACCOUNT" m))))
dispatch)
```

### Exercise 3.5

Monte Carlo integration is a method of estimating definite integrals by means of
Monte Carlo simulation. Consider computing the area of a region of space
described by a predicate p ( x , y ) that is true for points ( x , y ) in the
region and #f for points not in the region. For example, the region contained
within a circle of radius 3 centered at (5, 7) is described by the predicate
that tests whether ( x − 5 ) 2 + ( y − 7 ) 2 ≤ 3 2 . To estimate the area of the
region described by such a predicate, begin by choosing a rectangle that
contains the region. For example, a rectangle with diagonally opposite corners
at (2, 4) and (8, 10) contains the circle above. The desired integral is the
area of that portion of the rectangle that lies in the region. We can estimate
the integral by picking, at random, points ( x , y ) that lie in the rectangle,
and testing p ( x , y ) for each point to determine whether the point lies in
the region. If we try this with many points, then the fraction of points that
fall in the region should give an estimate of the proportion of the rectangle
that lies in the region. Hence, multiplying this fraction by the area of the
entire rectangle should produce an estimate of the integral.

Implement Monte Carlo integration as a procedure estimate-integral that takes as
arguments a predicate p, upper and lower bounds x1, x2, y1, and y2 for the
rectangle, and the number of trials to perform in order to produce the estimate.
Your procedure should use the same monte-carlo procedure that was used above to
estimate π . Use your estimate-integral to produce an estimate of π by measuring
the area of a unit circle.

You will find it useful to have a procedure that returns a number chosen at
random from a given range. The following random-in-range procedure implements
this in terms of the random procedure used in 1.2.6, which returns a nonnegative
number less than its input.136

```(define (random-in-range low high)
;; had to write my own
(+ low (random high)))

(define (estimate-integral p x1 x2 y1 y2 trials)
(define width (abs (- x2 x1)))
(define height (abs (- y2 y1)))
(define area (* width height))
(define (iter remaining passed)
(let* ((x (random-in-range x1 x2))
(y (random-in-range y1 y2))
(is-contained? (p x y)))
(cond ((= remaining 0) (/ passed trials))
(is-contained? (iter (dec remaining)
(inc passed)))
(else
(iter (dec remaining) passed)))))
(* area
(iter trials 0)))

(define (unit-circle-pred x y)
(<= (+ (* x x) (* y y)) 1))
```

### Exercise 3.6

It is useful to be able to reset a random-number generator to produce a sequence
starting from a given value. Design a new rand procedure that is called with an
argument that is either the symbol generate or the symbol reset and behaves as
follows: (rand 'generate) produces a new random number; ((rand 'reset)
⟨new-value⟩) resets the internal state variable to the designated ⟨new-value⟩.
Thus, by resetting the state, one can generate repeatable sequences. These are
very handy to have when testing and debugging programs that use random numbers.

```;; This is what I assume he meant??
(define (rand command)
(case command
('generate (random 10))
(else (λ (new) (seed->random-state new)))))

;; Utilities
(define (count-pairs x)
(if (not (pair? x))
0
(+ (count-pairs (car x))
(count-pairs (cdr x))
1)))
```

### Exercise 3.12:

The following procedure for appending lists was introduced in 2.2.1:

(define (append x y)
(if (null? x)
y
(cons (car x) (append (cdr x) y))))

Append forms a new list by successively consing the elements of x onto y. The
procedure append! is similar to append, but it is a mutator rather than a
constructor. It appends the lists by splicing them together, modifying the final
pair of x so that its cdr is now y. (It is an error to call append! with an
empty x.)

An infinite loop occurs (a cycle in the linked list has been made)

```(define (last-pair x)
(if (null? (cdr x))
x
(last-pair (cdr x))))

(define x (list 'a 'b))
(define y (list 'c 'd))
(define z (append x y))

;; Exercise 3.13
;; What happens if we try to compute (last-pair z)?
(define (make-cycle x)
(set-cdr! (last-pair x) x)
x)
```

### Exercise 3.14:

The following procedure is quite useful, although obscure:

(define (mystery x)
(define (loop x y)
(if (null? x)
y
(let ((temp (cdr x)))
(set-cdr! x y)
(loop temp x))))
(loop x '()))

Loop uses the “temporary” variable temp to hold the old value of the cdr of x,
since the set-cdr! on the next line destroys the cdr. Explain what mystery does
in general. Suppose v is defined by (define v (list 'a 'b 'c 'd)). Draw the
box-and-pointer diagram that represents the list to which v is bound. Suppose
that we now evaluate (define w (mystery v)). Draw box-and-pointer diagrams that
show the structures v and w after evaluating this expression. What would be
printed as the values of v and w?

Mystery requotes an array "in-place"

### Exercise 3.16

Ben Bitdiddle decides to write a procedure to count the number of pairs in any
list structure. “It’s easy,” he reasons. “The number of pairs in any structure
is the number in the car plus the number in the cdr plus one more to count the
current pair.” So Ben writes the following procedure:

(define (count-pairs x)
(if (not (pair? x))
0
(+ (count-pairs (car x))
(count-pairs (cdr x))
1)))

Show that this procedure is not correct. In particular, draw box-and-pointer
diagrams representing list structures made up of exactly three pairs for which
Ben’s procedure would return 3; return 4; return 7; never return at all.

```(define count-three-pairs '(a b c))
(define count-four-pairs '(a b c))
(define count-seven-pairs '(a b c))
(set-car! (cdr count-four-pairs) (cdr (cdr count-four-pairs)))
(set-car! count-seven-pairs (cdr count-seven-pairs))

#|
(count-pairs count-three-pairs) => 3
(count-pairs count-four-pairs)  => 4
(count-pairs count-seven-pairs) => 7
|#
```

### Exercise 3.17

Devise a correct version of the count-pairs procedure of Exercise 3.16 that
returns the number of distinct pairs in any structure.

(Hint: Traverse the structure, maintaining an auxiliary data structure that is
used to keep track of which pairs have already been counted.)

```(define (zv-count-pairs xs)
(define counted '())
(define (loop xs)
(cond ((not (pair? xs)) 1)
((null? xs) 0)
((memq (car xs) counted) 0)
(else
(begin
(set! counted (cons (car xs) counted))
(+ (loop (car xs))
(loop (cdr xs)))))))
(loop xs))
```

### Exercise 3.18

Write a procedure that examines a list and determines whether it contains a
cycle, that is, whether a program that tried to find the end of the list by
taking successive cdrs would go into an infinite loop. Exercise 3.13 constructed
such lists.

```(define (has-cycles? xs)
(define visited '())
(define (search ys)
(cond ((null? ys) #f)
((memq (car ys) visited) #t)
(else
(begin
(set! visited (cons (car ys) visited))
(search (cdr ys))))))
(search xs))
```

### Exercise 3.19

Redo Exercise 3.18 using an algorithm that takes only a constant amount of
space. (This requires a very clever idea.)

```(define* (linear-cycle-search x1
#:optional (x2 (cdr x1)))
(cond ((or (null? (cdr x1)) (null? (cdr x2))) #f)
((eq? x1 x2) #t)
(else (linear-cycle-search (cdr x1) (cdr (cdr x2))))))
```

### Exercise 3.21

Ben Bitdiddle decides to test the queue implementation described above. He types
in the procedures to the Lisp interpreter and proceeds to try them out:

“It’s all wrong!” he complains. “The interpreter’s response shows that the last
item is inserted into the queue twice. And when I delete both items, the second
b is still there, so the queue isn’t empty, even though it’s supposed to be.”
Eva Lu Ator suggests that Ben has misunderstood what is happening. “It’s not
that the items are going into the queue twice,” she explains. “It’s just that
the standard Lisp printer doesn’t know how to make sense of the queue
representation. If you want to see the queue printed correctly, you’ll have to
define your own print procedure for queues.” Explain what Eva Lu is talking
about. In particular, show why Ben’s examples produce the printed results that
they do. Define a procedure print-queue that takes a queue as input and prints
the sequence of items in the queue.

```(define (print-queue qs) (format #t "~a~%" (car qs)))
```

### Exercise 3.22

Instead of representing a queue as a pair of pointers, we can build a queue as a
procedure with local state. The local state will consist of pointers to the
beginning and the end of an ordinary list. Thus, the make-queue procedure will
have the form

(define (make-queue)
(let ((front-ptr … )
(rear-ptr … ))
⟨definitions of internal procedures⟩
(define (dispatch m) …)
dispatch))

Complete the definition of make-queue and provide implementations of the queue
operations using this representation.

```(define (make-curryq)
(let ((front-ptr '())
(rear-ptr '()))
(define (set-fptr! item) (set! front-ptr item))
(define (set-rptr! item) (set! rear-ptr item))
(define (empty-curryq?)
(null? front-ptr))
(define (front-curryq)
(if (empty-curryq?)
(error "FRONT on empty queue")
(car front-ptr)))
(define (insert-curryq! item)
(let ((new-pair (cons item '())))
(cond [(empty-curryq?)
(set-fptr! item)
(set-rptr! item)]
[else
(set! rear-ptr new-pair)
(set-rptr! new-pair)])))
(define (print-queue)
(format #t "~a~%" front-ptr))
(define (dispatch m)
(cond [(eq? m 'front-ptr) front-ptr]
[(eq? m 'rear-ptr) rear-ptr]
[(eq? m 'insert-queue!) insert-curryq!]
[(eq? m 'print-queue) print-queue]))
dispatch))
```

### Exercise 3.23

A deque (“double-ended queue”) is a sequence in which items can be inserted and
deleted at either the front or the rear. Operations on deques are the
constructor make-deque, the predicate empty-deque?, selectors front-deque and
rear-deque, and mutators front-insert-deque!, rear-insert-deque!,
front-delete-deque!, rear-delete-deque!. Show how to represent deques using
pairs, and give implementations of the operations. All operations should be
accomplished in Θ(1) steps.

This is the structure I've decided to use for the deque. There may be other
neat ways to encode a deque with cons-cells. I'd love to hear if anyone has
a better structure:

F: Front Ptr
B: Back Ptr
X: Value
/: Null or End

---—+
| F | B |------------–—+
-|-—+ |
V V
----- ---—+ -----
| * | * |–>| * | * |–>| * | / |
-|-—+ -|-—+ -|-—+
V ^—+ V ^—+ V
----- | ---—+ | ---—+
| X | / | | | X | * | | | X | * |
---—+ | ----- | -----
| | | |
------- -------

(define (make-deque) '(() . ()))
(define (empty-deque? dq) (null? (front-deque dq)))
(define (front-deque dq) (car dq))
(define (rear-deque dq) (cdr dq))
(define (next-deque lst) (if (null? lst) '() (cdr lst)))
(define (prev-deque lst) (if (null? lst) '() (cdar lst)))

(define (front-insert-deque! dq value)
(let ([new-elt (cons (cons value '()) '())])
(cond
((empty-deque? dq)
(set-car! dq new-elt) (set-cdr! dq new-elt)
dq)
(else
;; link our next element to the current front
(set-cdr! new-elt (front-deque dq))
;; find the next element to make a backwards link
(set-cdr! (car (front-deque dq)) new-elt)
(set-car! dq new-elt)
dq))))

(define (rear-insert-deque! dq value)
(let ([new-elt (cons (cons value '()) '())])
(cond
((empty-deque? dq)
(set-car! dq new-elt) (set-cdr! dq new-elt)
dq)
(else
(set-cdr! (car new-elt) (rear-deque dq))
(set-cdr! (rear-deque dq) new-elt)
(set-cdr! dq new-elt)
dq))))

(define (front-delete-deque! dq)
(let ([next (next-deque (front-deque dq))]
[front (front-deque dq)])
(cond
((null? next) (set-car! dq '()) (set-cdr! dq '()))
(else
(set-car! dq next)
(set-cdr! (car (front-deque dq)) '())))
front))

(define (rear-delete-deque! dq)
(let ([rear (rear-deque dq)]
[prev (prev-deque (rear-deque dq))])
(cond
((null? rear) (set-car! dq '()) (set-cdr! dq '()))
(else
(set-cdr! dq prev)
(set-cdr! (rear-deque dq) '())))
rear))

### Exercise 3.24:

In the table implementations above, the keys are tested for equality using
`equal?' (called by `assoc'). This is not always the appropriate test. For
instance, we might have a table with numeric keys in which we don't need an
exact match to the number we're looking up, but only a number within some
tolerance of it. Design a table constructor `make-table' that takes as an
argument a `same-key?' procedure that will be used to test "equality" of
keys. `Make-table' should return a `dispatch' procedure that can be used to
access appropriate `lookup' and `insert!' procedures for a local table.

```(define (make-table-with-key same-key?)
(let ((local-table (list '*table*)))
;; just redefine `assoc' with `same-key?'
(define (assoc key records)
(cond ((null? records) #f)
((same-key? key (caar records)) (car records))
(else (assoc key (cdr records)))))
(define (lookup key-1 key-2)
(let ((subtable (assoc key-1 (cdr local-table))))
(if subtable
(let ((record (assoc key-2 (cdr subtable))))
(if record
(cdr record)
#f))
#f)))
(define (insert! key-1 key-2 value)
(let ((subtable (assoc key-1 (cdr local-table))))
(if subtable
(let ((record (assoc key-2 (cdr subtable))))
(if record
(set-cdr! record value)
(set-cdr! subtable
(cons (cons key-2 value)
(cdr subtable)))))
(set-cdr! local-table
(cons (list key-1
(cons key-2 value))
(cdr local-table))))))
(define (dispatch m)
(cond ((eq? m 'lookup-proc) lookup)
((eq? m 'insert-proc!) insert!)))
dispatch))
```

### Exercise 3.25

Generalizing one and two-dimensional tables, show how to implement a table
in which values are stored under an arbitrary number of keys and different
values may be stored under different numbers of keys. The `lookup' and
`insert!' procedures should take as input a list of keys used to access the
table.

The easiest way to accomplish this is to accept variadic arguments to `insert' and `lookup', folding them into a string or using the list directly (which `equal?' can compare)

### Exercise 3.26

To search a table as implemented above, one needs to scan through the list
of records. This is basically the unordered list representation of section
*Note 2-3-3. For large tables, it may be more efficient to structure the
table in a different manner. Describe a table implementation where the
(key, value) records are organized using a binary tree, assuming that keys
can be ordered in some way (e.g., numerically or alphabetically). (Compare
Exercise 2-66 of Chapter 2)

The value that is to be inserted is converted into it's numeric form. Insert & Lookup function as you would expect

### Exercise 3.27

"Memoization" (also called "tabulation") is a technique that enables a
procedure to record, in a local table, values that have previously been
computed. This technique can make a vast difference in the performance of a
program. A memoized procedure maintains a table in which values of previous
calls are stored using as keys the arguments that produced the values. When
the memoized procedure is asked to compute a value, it first checks the
table to see if the value is already there and, if so, just returns that
value. Otherwise, it computes the new value in the ordinary way and stores
this in the table. As an example of memoization, recall from section
1-2-2 the exponential process for computing Fibonacci numbers:

(define (fib n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (fib (- n 1))
(fib (- n 2))))))

The memoized version of the same procedure is

(define memo-fib
(memoize (lambda (n)
(cond ((= n 0) 0)
((= n 1) 1)
(else (+ (memo-fib (- n 1))
(memo-fib (- n 2))))))))

where the memoizer is defined as

(define (memoize f)
(let ((table (make-table)))
(lambda (x)
(let ((previously-computed-result (lookup x table)))
(or previously-computed-result
(let ((result (f x)))
(insert! x result table)
result))))))

Draw an environment diagram to analyze the computation of `(memo-fib
3)'. Explain why `memo-fib' computes the nth Fibonacci number in a number
of steps proportional to n. Would the scheme still work if we had simply
defined `memo-fib' to be `(memoize fib)'?

memo-fib is O(N) because the fibonacci sequence can simply be computed in 2*(Σ(N)) steps (half of which are 'precomputed') The scheme would not work if each function were freshly memoized because the `table' would not be shared between the various applications of `memo-fib'.

### Exercise 3.28

Define an or-gate as a primitive function box. Your or-gate constructor should
be similar to and-gate.

```(define or-gate-delay 5)
(define (or-gate a1 a2 output)
(define (or-action-procedure)
(let ((new-value
(logior (signal-value a1)
(signal-value a2))))
(after-delay
or-gate-delay
(λ ()
(set-signal! output new-value)))))
'ok)
```

### Exercise 3.29

Another way to construct an or-gate is as a compound digital logic device, built
from and-gates and inverters. Define a procedure or-gate that accomplishes this.
What is the delay time of the or-gate in terms of and-gate-delay and
inverter-delay?

(!a1) && a2 is congruent to a1 || a2, it is as fast as (AND-DELAY + INVERTERDELAY)

### TODO Exercise 3.30

Figure 3.27 shows a ripple-carry adder formed by stringing together n
binary numbers. The inputs A 1 , A 2 , A 3 , …, A n and B 1 , B 2 , B 3 , …, B n
are the two binary numbers to be added (each A k and B k is a 0 or a 1). The
circuit generates S 1 , S 2 , S 3 , …, S n , the n bits of the sum, and C , the
this circuit. The procedure should take as arguments three lists of n wires
each—the A k , the B k , and the S k —and also another wire C . The major
drawback of the ripple-carry adder is the need to wait for the carry signals to
propagate. What is the delay needed to obtain the complete output from an n -bit
ripple-carry adder, expressed in terms of the delays for and-gates, or-gates,
and inverters?

### Exercise 3.31

The internal procedure `accept-action-procedure!' defined in make-wire specifies
that when a new action procedure is added to a wire, the procedure is
immediately run. Explain why this initialization is necessary. In particular,
trace through the half-adder example in the paragraphs above and say how the
system’s response would differ if we had defined accept-action-procedure! as

(define (accept-action-procedure! proc)
(set! action-procedures (cons proc action-procedures)))

the signal value must be initialized or the entire system will run the action
procedures (no matter what has changed)

### TODO Exercise 3.32

The procedures to be run during each time segment of the agenda are kept in a
queue. Thus, the procedures for each segment are called in the order in which
they were added to the agenda (first in, first out). Explain why this order must
be used. In particular, trace the behavior of an and-gate whose inputs change
from 0, 1 to 1, 0 in the same segment and say how the behavior would differ if
we stored a segment’s procedures in an ordinary list, adding and removing
procedures only at the front (last in, first out).

### Exercise 3.33

Using primitive multiplier, adder, and constant constraints, define a procedure
averager that takes three connectors a, b, and c as inputs and establishes the
constraint that the value of c is the average of the values of a and b.

```(define (averager a b c)
(with-connectors (half sum)
(constant 0.5 half)
(multiplier half sum c)
'ok))
```

### Exercise 3.34

Louis Reasoner wants to build a squarer, a constraint device with two terminals
such that the value of connector b on the second terminal will always be the
square of the value a on the first terminal. He proposes the following simple

(define (squarer a b) (multiplier a a b))

There is a serious flaw in this idea. Explain.

The value of `a' is not "duplicated" across – so `process-new-value' only reads either `rhs' or `lhs''s value

### Exercise 3.35

Ben Bitdiddle tells Louis that one way to avoid the trouble in
Exercise 3.34 is to define a squarer as a new primitive constraint. Fill in the
missing portions in Ben’s outline for a procedure to implement such a
constraint:

(define (squarer a b)
(define (process-new-value)
(if (has-value? b)
(if (< (get-value b) 0)
(error "square less than 0:
SQUARER"
(get-value b))
⟨alternative1⟩)
⟨alternative2⟩))
(define (process-forget-value) ⟨body1⟩)
(define (me request) ⟨body2⟩)
⟨rest of definition⟩
me)

```(define-class <squarer> (<constraint>)
;; in squarer, there is essentially only one value
(rhs #:allocation #:virtual
#:slot-ref (lambda (o) (slot-ref o 'lhs))
#:slot-set! (lambda (o s) (slot-set! o 'lhs s)))
;; strictly speaking these are not nessasary, as they are defined directly in
;; `process-new-value', they are kept for posteriety.
(operator #:init-value square)
(inverse-operator #:init-value sqrt))

(define-method (process-new-value (c <squarer>))
(let* ([lhs-conn (lhs c)]
[total-conn (total c)]
[has-total? (has-value? total-conn)]
[has-lhs? (has-value? lhs-conn)])
;; Determine what values *are* known and set the appropriate connector.
(cond
;; (lhs < 0) => error
[(and (has-lhs?
(< (connector-value lhs-conn) 0)))
(error "square less than 0: SQUARER" (connector-value lhs-conn))]

;; lhs = √total
[has-total?
(set-value! lhs-conn (sqrt (connector-value total-conn)) c)]

;; total = lh²
[has-lhs?
(set-value! total-conn (square (connector-value lhs-conn)) c)])))

(define-method (process-forget-value (c <squarer>))
(forget-value! (lhs c) c)
(forget-value! (total c) c)
(process-new-value c))
```

### TODO Exercise 3.36

Suppose we evaluate the following sequence of expressions in the global
environment:

(define a (make-connector)) (define b (make-connector)) (set-value! a 10 'user)

At some time during evaluation of the set-value!, the following expression from
the connector’s local procedure is evaluated:

Draw an environment diagram showing the environment in which the above
expression is evaluated.

### Exercise 3.37

The celsius-fahrenheit-converter procedure is cumbersome when compared with a
more expression-oriented style of definition, such as

(define (celsius-fahrenheit-converter x)
(c+ (c* (c/ (cv 9) (cv 5)) x)

(cv 32)))

(define C (make-connector))
(define F (celsius-fahrenheit-converter C))

Here c+, c*, etc. are the “constraint” versions of the arithmetic operations.
For example, c+ takes two connectors as arguments and returns a connector that
is related to these by an adder constraint:

(define (c+ x y)
(let ((z (make-connector))) (adder x y z) z))

Define analogous procedures c-, c*, c/, and cv (constant value) that enable us
to define compound constraints as in the converter example above.

```(define (c+ augend addend)
(with-connectors (sum)
sum))

(define (c- minuend subtrahend)
(with-connectors (difference)
difference))

(define (c* multiplicand m2)
(with-connectors (product)
(multiplier multiplicand  m2 product)
product))

(define (c/ dividend divisor)
(with-connectors (quotient)
(multiplier quotient divisor dividend)
quotient))
(define (cv value)
(with-connectors (result)
(constant value result)
result))
```

### Exercise 3.38

Suppose that Peter, Paul, and Mary share a joint bank account that initially
contains \$100. Concurrently, Peter deposits \$10, Paul withdraws \$20, and Mary
withdraws half the money in the account, by executing the following commands:

Peter: (set! balance (+ balance 10))
Paul: (set! balance (- balance 20))
Mary: (set! balance (- balance (/ balance 2)))

1. List all the different possible values for balance after these three
transactions have been completed, assuming that the banking system forces the
three processes to run sequentially in some order.

2. What are some other values that could be produced if the system allows the
processes to be interleaved? Draw timing diagrams like the one in Figure 3.29 to
explain how these values can occur.

Peter->Paul->Mary: (calc-eval "((100+10)-20)/2") => 45
Peter->Mary->Paul: (calc-eval "((100+10)/2)-20") => 35
Mary->Paul->Peter: (calc-eval "((100 / 2) - 20) + 20") => 50
Mary->Peter->Paul: (calc-eval "((100 / 2) + 10) - 20") => 40
Paul->Peter->Mary: (calc-eval "((100 - 20) + 10) / 2") => 45
Paul->Mary->Peter: (calc-eval "((100 - 20) / 2) + 10") => 50

### Exercise 3.39

Which of the five possibilities in the parallel execution shown above remain if
we instead serialize execution as follows:

(define x 10)
(define s (make-serializer))
(parallel-execute
(lambda ()
(set! x ((s (lambda () (* x x))))))
(s (lambda () (set! x (+ x 1)))))

101, 100, 121

### Exercise 3.40

Give all possible values of x that can result from executing

(define x 10)
(parallel-execute
(lambda () (set! x (* x x)))
(lambda () (set! x (* x x x))))

Which of these possibilities remain if we instead use serialized procedures:

(define x 10)
(define s (make-serializer))
(parallel-execute
(s (lambda () (set! x (* x x))))
(s (lambda () (set! x (* x x x)))))

x*6 (multiplication is commutative)

### Exercise 3.41

Ben Bitdiddle worries that it would be better to implement the bank account as
follows (where the commented line has been changed):

(define (make-account balance)
(define (withdraw amount)
(if (>= balance amount)
(begin
(set! balance
(- balance amount))
balance)
"Insufficient funds"))
(define (deposit amount)
(set! balance (+ balance amount))
balance)
(let ((protected (make-serializer)))
(define (dispatch m)
(cond ((eq? m 'withdraw)
(protected withdraw))
((eq? m 'deposit)
(protected deposit))
((eq? m 'balance)
((protected
(lambda ()
balance)))) ; serialized
(else
(error
"Unknown request:
MAKE-ACCOUNT"
m))))
dispatch))

because allowing unserialized access to the bank balance can result in anomalous
behavior. Do you agree? Is there any scenario that demonstrates Ben’s concern?

First off, this question is phrased in a really shitty way. Second off, no BALANCE is safe. the other functions are UNSAFE

### Exercise 3.42

Ben Bitdiddle suggests that it’s a waste of time to create a new serialized
procedure in response to every withdraw and deposit message. He says that
make-account could be changed so that the calls to protected are done outside
the dispatch procedure. That is, an account would return the same serialized
procedure (which was created at the same time as the account) each time it is

(define (make-account balance)
(define (withdraw amount)
(if (>= balance amount)
(begin (set! balance
(- balance amount))
balance)
"Insufficient funds"))
(define (deposit amount)
(set! balance (+ balance amount))
balance)
(let ((protected (make-serializer)))
(let ((protected-withdraw
(protected withdraw))
(protected-deposit
(protected deposit)))
(define (dispatch m)
(cond ((eq? m 'withdraw)
protected-withdraw)
((eq? m 'deposit)
protected-deposit)
((eq? m 'balance)
balance)
(else
(error "Unknown request: MAKE-ACCOUNT"
m))))
dispatch)))

This is fine

### TODO Exercise 3.43

Suppose that the balances in three accounts start out as \$10, \$20, and \$30,
and that multiple processes run, exchanging the balances in the accounts.
Argue that if the processes are run sequentially, after any number of
concurrent exchanges, the account balances should be \$10, \$20, and \$30 in
some order. Draw a timing diagram like the one in *Note Figure 3-29:: to
show how this condition can be violated if the exchanges are implemented
using the first version of the account-exchange program in this section. On
the other hand, argue that even with this `exchange' program, the sum of
the balances in the accounts will be preserved. Draw a timing diagram to
show how even this condition would be violated if we did not serialize the
transactions on individual accounts.