►zthomae’s SICP solutions
▼3 Chapter 3
3.1 Exercise 3.1
3.2 Exercise 3.2
3.3 Exercise 3.3
3.4 Exercise 3.4
3.5 Exercise 3.5
3.6 Exercise 3.6
3.7 Exercise 3.7
3.8 Exercise 3.8
3.9 Exercise 3.9
3.10 Exercise 3.10
3.11 Exercise 3.11
3.12 Exercise 3.12
3.13 Exercise 3.13
3.14 Exercise 3.14
3.15 Exercise 3.15
3.16 Exercise 3.16
3.17 Exercise 3.17
3.18 Exercise 3.18
3.19 Exercise 3.19
3.20 Exercise 3.20
3.21 Exercise 3.21
3.22 Exercise 3.22
3.23 Exercise 3.23
3.24 Exercise 3.24
3.25 Exercise 3.25
3.26 Exercise 3.26
3.27 Exercise 3.27
3.28 Exercise 3.28
3.29 Exercise 3.29
3.30 Exercise 3.30
3.31 Exercise 3.31
3.32 Exercise 3.32
3.33 Exercise 3.33
3.34 Exercise 3.34
3.35 Exercise 3.35
3.36 Exercise 3.36
3.37 Exercise 3.37
3.38 Exercise 3.38
3.39 Exercise 3.39
3.40 Exercise 3.40
3.41 Exercise 3.41
3.42 Exercise 3.42
3.43 Exercise 3.43
3.44 Exercise 3.44
3.45 Exercise 3.45
3.46 Exercise 3.46
3.47 Exercise 3.47
3.48 Exercise 3.48
3.49 Exercise 3.49
3.50 Exercise 3.50
3.51 Exercise 3.51
3.52 Exercise 3.52
3.53 Exercise 3.53
3.54 Exercise 3.54
3.55 Exercise 3.55
3.56 Exercise 3.56
3.57 Exercise 3.57
3.58 Exercise 3.58
3.59 Exercise 3.59
3.60 Exercise 3.60
3.61 Exercise 3.61
3.62 Exercise 3.62
3.63 Exercise 3.63
3.64 Exercise 3.64
3.65 Exercise 3.65
3.66 Exercise 3.66
3.67 Exercise 3.67
3.68 Exercise 3.68
3.69 Exercise 3.69
3.70 Exercise 3.70
3.71 Exercise 3.71
3.72 Exercise 3.72
3.73 Exercise 3.73
3.74 Exercise 3.74
3.75 Exercise 3.75
3.76 Exercise 3.76
3.77 Exercise 3.77
3.78 Exercise 3.78
3.79 Exercise 3.79
3.80 Exercise 3.80
3.81 Exercise 3.81
3.82 Exercise 3.82
    ← prev  up  next → 

3.70 Exercise 3.70

merge-weighted can be defined as follows (note that, unlike merge, this does not deduplicate results):

(define (merge-weighted weight s t)
  (cond ((stream-null? s) t)
        ((stream-null? t) s)
        (else
         (let* ((a (stream-car s))
                (b (stream-car t))
                (wa (weight a))
                (wb (weight b)))
           (if (< wa wb)
               (cons-stream a (merge-weighted weight (stream-cdr s) t))
               (cons-stream b (merge-weighted weight s (stream-cdr t))))))))

We can then weight pairs from two streams like this:

(define (weighted-pairs weight s t)
  (if (or (stream-null? s) (stream-null? t))
      the-empty-stream
      (cons-stream
       (list (stream-car s) (stream-car t))
       (merge-weighted weight
                       (stream-map (lambda (x) (list (stream-car s) x))
                                   (stream-cdr t))
                       (weighted-pairs weight (stream-cdr s) (stream-cdr t))))))

For examples, the pairs of integers weighted by the sums of their elements:

> (display-stream
   (take-stream (weighted-pairs (lambda (p) (+ (car p) (cadr p)))
                                integers
                                integers)
                20))

(1 1)

(1 2)

(2 2)

(1 3)

(2 3)

(1 4)

(3 3)

(2 4)

(1 5)

(3 4)

(2 5)

(1 6)

(4 4)

(3 5)

(2 6)

(1 7)

(4 5)

(3 6)

(2 7)

(1 8)

'done

And the pairs of integers that are not divisible by 2, 3, or 5 ordered by the sum 2i + 3j + 5ij

> (define filtered-integers
    (stream-filter (lambda (x) (not (or (divisible? x 2)
                                        (divisible? x 3)
                                        (divisible? x 5))))
                   integers))
> (define (weight p)
    (let ((i (car p))
          (j (cadr p)))
      (+ (* 2 i) (* 3 j) (* 5 (+ i j)))))
> (display-stream
   (take-stream (weighted-pairs weight
                                filtered-integers
                                filtered-integers)
                20))

(1 1)

(1 7)

(1 11)

(7 7)

(1 13)

(7 11)

(1 17)

(7 13)

(1 19)

(11 11)

(11 13)

(7 17)

(1 23)

(13 13)

(7 19)

(11 17)

(13 17)

(11 19)

(7 23)

(1 29)

'done

    ← prev  up  next →