Exam 3: Sophisticated Scheming

Topics: List recursion, higher-order procedures, encapsulating control.

As you may recall, we began our investigation of recursion by considering how we might step through a list of numbers, adding them (or multiplying them or ...). Here are variants of the two versions we wrote:

One uses simple recursion.

(define sum-right
  (lambda (numbers)
     (if (null? (cdr numbers))
         (car numbers)
         (+ (car numbers) (sum-right (cdr numbers))))))

The other uses a helper to accumulate the results.

(define sum-left
  (lambda (numbers)
    (let kernel ((so-far (car numbers))
                 (remaining (cdr numbers)))
      (if (null? remaining)
          so-far
          (kernel (+ so-far (car remaining)) 
                  (cdr remaining))))))

If you think carefully about it, the two processes compute results slightly differently. Given the list (n0 n1 n2 n3 n4), the first computes

(+ n0 (+ n1 (+ n2 (+ n3 n4))))

while the second computes

(+ (+ (+ (+ n0 n1) n2) n3) n4)

For addition, this doesn't make a difference. If the operation were subtraction, it would certainly make a difference. (Rimshot!)

The process of combining a list of values using a binary procedure is quite common. We've seen it for addition, subtraction, and multiplication. We might also use it for appending strings and many other operations. Computer scientists have various names for such a process. We'll call it fold, but others use inject (as in “inject this operation into this list”) or reduce (as in, “reduce this list to a single value”).

(proc v0 (proc v1 (proc v2 (... (proc vn-1  vn) ... ))))

> (fold-right + (list 1 2 3 4))
10
> (fold-right * (list 1 2 3 4))
24
> (fold-right - (list 1 2 3 4))
-2
> (fold-right (lambda (s1 s2) (string-append s1 ", " s2)) (list "sentient" "malicious" "powerful" "stupid"))
"sentient, malicious, powerful, stupid"
> (fold-right list (list 'a 'b 'c 'd 'e))
(a (b (c (d e))))

(proc (proc ... (proc (proc v0 v1) v2) ... vn-1) vn)

> (fold-left + (list 1 2 3 4))
10
> (fold-left * (list 1 2 3 4))
24
> (fold-left - (list 1 2 3 4))
-8
> (fold-left (lambda (s1 s2) (string-append s1 ", " s2)) (list "sentient" "malicious" "powerful" "stupid"))
"sentient, malicious, powerful, stupid"
> (fold-left list (list 'a 'b 'c 'd 'e))
((((a b) c) d) e)

Topics: Deep recursion, pair structures, predicates.

In the lab on trees, you wrote a predicate color-tree? that determines whether every leaf in a tree is a color. Generalize this idea by writing the predicate (tree-all? pred? tree), which indicates whether the predicate pred? is satisfied for all leaves in tree. You need not document tree-all?.

For example,

> (tree-all? number? (cons (cons (cons 1 2) (cons 3 4)) (cons 5 (cons 6 7))))
#t
> (tree-all? even? (cons (cons (cons 1 2) (cons 3 4)) (cons 5 (cons 6 7))))
#f
> (tree-all? char? (cons (cons #\a #\b) #\c))
#t
> (tree-all? char? (cons (cons #\a #\b) "c"))
#f
> (tree-all? odd? 1)
#t
> (tree-all? char? 1)
#f

Topics: Higher-order procedures, code reading, documentation.

Many implementations of Scheme contain the following procedures.

(define negate
  (lambda (pred?)
    (lambda (val)
      (not (pred? val)))))

(define select
  (lambda (lst pred?)
    (cond
      ((null? lst)
       null)
      ((pred? (car lst))
       (cons (car lst) (select (cdr lst) pred?)))
      (else
       (select (cdr lst) pred?)))))

(define member?
  (lambda (val lst)
    (and (not (null? lst))
         (or (equal? val (car lst))
             (member? val (cdr lst))))))

Suppose we've defined the following procedure using those standard procedures.

(define list-subtract
  (lambda (lst1 lst2)
    (select lst2 (negate (r-s member? lst1)))))

Read and experiment with list-subtract to understand its purpose and use. Then write 8 Ps documentation for list-subtract. In addition to the standard 6 Ps, include two additional sections:

Topics: Higher-order procedures, sorting, documentation, code reading, code analysis, efficiency.

Some 151 students have decided to implement selection sort. One of the first things they want to do is find the smallest element in a list. They understand that “smallest” may depend on our understanding of order. So their algorithm takes two inputs, the list to process and a may-precede? function that lets us determine whether one value may precede another.

And they work out the logic.

Here's their implementation.

(define smallest
  (lambda (lst may-precede?)
    (if (= (length lst) 1)
        (car lst)
        (let ([smallest-remaining (smallest (cdr lst) may-precede?)])
          (if (may-precede? (car lst) smallest-remaining)
              (car lst) 
              smallest-remaining)))))

And a few sample runs.

> (smallest (list 5 1 2 3 4 0 6) <=)
0
> (smallest (list 5 1 2 3 8 4 0 6) <=)
0
> (smallest (list 5 1 2 3 8 4 0 6) >=)
8
> (smallest (list "alpha" "beta" "aardvark" "foxtrot" "echo") string<=?)
"aardvark"

a. Document this procedure.

b. Your instructors have some significant concerns about the running time of this procedure. Explain why by analyzing the number of recursive calls to the length procedure.

To do this, replace each call to the built-in length procedure with a call to the new procedure, my-length:

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

Augment my-length so that it counts the number of times it is called. Do some experiments and summarize what you learn.

c. Revise the definition of smallest to address the issue you identified in part b.

Topics: Image transformations, numeric values, anonymous procedures, RGB colors.

In this problem, we consider an approach to keeping messages secret. Steganography is the process of hiding a message in an image such that no one, other than the sender and receiver, even knows there is any hidden information. One approach to hiding an image inside a full-color image is to use the "least significant bits" to store the secret image. In the same way you're not likely to notice if two numbers far after the decimal point have changed, no one is likely to notice if the colors in a photo have been changed by only 1/8 from the original brightness values. How do we do that?

Just like the decimal numbers you're probably used to have "places" for the ones digit, tens digit, thousands digit, etc., the numbers storing the colors have eight "places" for binary bits that are either zero or one. We can shift and manipulate these binary bits by dividing and multiplying the number by powers of two (rather than powers of ten as for decimal numbers), as we do in the following.

Here is the algorithm we used to create a steganographic image.

Decoding the image is much simpler. At each pixel, for each color channel you can get the last three bits (which contain our hidden image) by taking its modulus with respect to 8 and rescaling the result to the range 0-255.

(a) Write, but do not document, a procedure, (image-steg-decode steg-image), that takes a steganographic image produced using this algorithm and produces the secret image.

Note: Use image-variant in your procedure. You should write your procedure with as little repeated code as possible. However, the fewer lambdas you use to write your solution the more points you will receive. Bonus points will be given for a completely lambda-free solution.

(b) Download this image of the kitten and test your procedure on it. Describe the secret image hidden inside it.

Topics: Divide-and-conquer, numeric recursion, local procedure bindings.

We learned the divide-and-conquer strategy when studying binary search. We have also applied that strategy to the problem of sorting. Let's consider one other instance in which divide-and-conquer may help: computing cube roots.

To compute the cube root of a number, n, we start with two estimates, one that we know is lower than the cube root and one that we know is higher than the cube root. We repeatedly find the average of those two numbers and refine our guess. We stop when the cube of the average is “close enough” to n.

What should we start as the lower-bound and upper-bound of the cube root? Well, if n is at least 1, we can use 0 as the lower-bound and n as the upper bound.

For example, our procedure produces the following sequence of guesses to find the cube root of 2 with an accuracy of 3 decimal places.

>(cube-root 2.0)
(lower: 0.0 upper: 2.0 avg: 1.0 avg-cubed: 1.0)
(lower: 1.0 upper: 2.0 avg: 1.5 avg-cubed: 3.375)
(lower: 1.0 upper: 1.5 avg: 1.25 avg-cubed: 1.953125)
(lower: 1.25 upper: 1.5 avg: 1.375 avg-cubed: 2.599609375)
(lower: 1.25 upper: 1.375 avg: 1.3125 avg-cubed: 2.260986328)
(lower: 1.25 upper: 1.3125 avg: 1.28125 avg-cubed: 2.103302002)
(lower: 1.25 upper: 1.28125 avg: 1.265625 avg-cubed: 2.02728653)
(lower: 1.25 upper: 1.265625 avg: 1.2578125 avg-cubed: 1.989975452)
(lower: 1.2578125 upper: 1.265625 avg: 1.26171875 avg-cubed: 2.008573234)
(lower: 1.2578125 upper: 1.26171875 avg: 1.259765625 avg-cubed: 1.999259926)
1.259765625

Write, but do not document, a procedure, (cube-root n), which should approximate the cube root of n to three decimal places of accuracy. That is, the difference between n and the cube of (cube-root n) should be less than 0.001. You can assume that n is at least one.

Topics: Repetition, images as pixels, randomness.

Consider the following algorithm for drawing a shape.

Repeat many times:

We call this a Monte Carlo method; just like there is randomness at a casino, there is randomness in our method. You could think of this approach to drawing as like spray-painting through a stencil: each position inside the shape has some probability of being painted, but it's unpredictable which ones will actually be chosen.

Write, but do not document, a procedure, (stencil-quarter-circle radius n color). Your procedure should use the following algorithm.

The result should look something like this:

> (image-show (stencil-quarter-circle 100 5000 (rgb-new 0 0 0)))

Topics: Numeric recursion, randomness.

The technique you just used to “spray-paint” a quarter-circle forms the basis of a Monte Carlo method for estimating the value of pi.

Consider the quarter-circle with radius 1. We select N random points where both the x and y values fall between 0 and 1. As we go along, we count how many of those points fall within the quarter-circle; call this M.

Observe that M/N is equal to the ratio between the area of the quarter-circle and the area of the unit square. So, we estimate that pi is approximately M/N * 4, and produce this value.

The larger N is, the better our estimate will be.

Write and document a procedure, (estimate-pi n), which implements this algorithm.

In your sample output, show that providing larger values of n leads to increasingly precise estimates. For example:

> pi
3.141592653589793
> (estimate-pi 10)
3.6
> (estimate-pi 100)
3.0
> (estimate-pi 1000)
3.204
> (estimate-pi 10000)
3.1304
> (estimate-pi 100000)
3.1503
> (estimate-pi 1000000)
3.141568

Topics: Strings, numeric recursion, verifying preconditions.

As you may recall, (substring str start finish) extracts a substring from str that runs from position start to position finish-1. The string-length procedure lets you find the length of a string.

Write, but do not document, a procedure, (all-substrings str len), that generates a list of all the substrings of str of length len. For full credit, your procedure should verify its preconditions. For example,

> (all-substrings "television" 3)
("tel" "ele" "lev" "evi" "vis" "isi" "sio" "ion")
> (all-substrings "cat" 3)
("cat")
> (all-substrings "hi" 3)
Error: substrings cannot be longer than the given string.

Topics: Association lists, searching, vectors.

In standard Scheme, an association list is a list of lists. Each sublist is called a “record”. For example, consider this association list from the reading on association lists:

;;; Value:
;;;   named-colors
;;; Type:
;;;   List of lists.
;;;   Each sublist is of length at least four and contains a name,
;;;     red, green, and blue components, and a sequence of attributes.
;;;   Each component is an integer between 0 and 255, inclusive.
;;; Contents:
;;;   A list of common colors, their components, and some attributes.
(define named-colors
  (list (list "black" 0 0 0)
        (list "blah grey" 128 128 128)
        (list "blood red" 102 0 0)
        (list "blue" 0 0 255)
        (list "green" 0 128 0)
        (list "indigo" 102 0 255)
        (list "medium grey" 128 128 128)
        (list "orange" 255 119 0)
        (list "red" 255 0 0)
        (list "violet" 79 47 79)
        (list "white" 255 255 255)
        (list "violet red" 204 50 153)
        (list "yellow" 255 255 0)))

But, we often think of records as having a fixed length, as above. If all records are the same length, would it make more sense to represent each record as a vector? For example, consider the following definition:

(define color-records
  (list (vector "black" 0 0 0)
        (vector "blah grey" 128 128 128)
        (vector "blood red" 102 0 0)
        (vector "blue" 0 0 255)
        (vector "green" 0 128 0)
        (vector "indigo" 102 0 255)
        (vector "medium grey" 128 128 128)
        (vector "orange" 255 119 0)
        (vector "red" 255 0 0)
        (vector "violet" 79 47 79)
        (vector "white" 255 255 255)
        (vector "violet red" 204 50 153)
        (vector "yellow" 255 255 0)))

Storing each record as a vector allows us to look up any value in a record with equal speed. As with standard association lists, we will assume that the key is found in the first position of each record.

Write, but do not document, a procedure, (assoc-vector list-of-vectors key). Your procedure should search the list-of-vectors until it finds a record with the given key as its first value. If no such record is found, your procedure should return #f.

For example,

> (assoc-vector color-records "red")
#("red" 255 0 0)
> (assoc-vector color-records "plaid")
#f

You may not use vector->list in solving this problem!