chapter-2/ex-2.53.txt

@@ -1,7 +0,0 @@
-(list 'a 'b 'c) -> (a b c)
-(list (list 'george)) -> ((george))
-(cdr '((x1 x2) (y1 y2))) -> ((y1 y2))
-(cadr '((x1 x2) (y1 y2))) -> (y1 y2)
-(pair? (car '(a short list))) -> #f
-(memq 'red '((red shoes) (blue socks))) -> #f
-(memq 'red '(red shoes blue socks)) -> (red shoes blue socks)

chapter-2/ex-2.54.scm

@@ -1,8 +0,0 @@
-#lang sicp
-
-(define (equal? a b)
-  (cond ((and (pair? a) (pair? b))
-         (and (equal? (car a) (car b)) (equal? (cdr a) (cdr b))))
-        ((and (not (pair? a)) (not (pair? b)))
-         (and (eq? a b)))
-        (else #f)))

chapter-2/ex-2.55.txt

@@ -1,6 +0,0 @@
-When typing (car ''abracadabra), the interpreter will transform the expression
-into: (car (quote (quote abracadabra))), then it will evaluate.
-First the symbol car becomes the car procedure, then quote gets evaluated as a
-special form, which means the surrounded expression should be left
-unevaluated, so we get something like: (#<car:procedure> (quote abracadabra)),
-now car gets applied, and we get the expected result.

chapter-2/ex-2.56.scm

@@ -1,78 +0,0 @@
-#lang sicp
-
-(define (variable? x) (symbol? x))
-(define (same-variable? v1 v2)
-  (and (variable? v1) (variable? v2) (eq? v1 v2)))
-
-(define (=number? exp num) (and (number? exp) (= exp num)))
-
-(define (make-sum a1 a2)
-  (cond ((=number? a1 0) a2)
-        ((=number? a2 0) a1)
-        ((and (number? a1) (number? a2))
-         (+ a1 a2))
-        (else (list '+ a1 a2))))
-
-(define (make-product m1 m2)
-  (cond ((or (=number? m1 0) (=number? m2 0)) 0)
-        ((=number? m1 1) m2)
-        ((=number? m2 1) m1)
-        ((and (number? m1) (number? m2)) (* m1 m2))
-        (else (list '* m1 m2))))
-
-(define (sum? x) (and (pair? x) (eq? (car x) '+)))
-(define (addend s) (cadr s))
-(define (augend s) (caddr s))
-(define (product? x) (and (pair? x) (eq? (car x) '*)))
-(define (multiplier p) (cadr p))
-(define (multiplicand p) (caddr p))
-
-; for the purposes of our exponentiation exercise, we need to determine whether
-; the exponent is constant so that we can apply the rule correctly
-(define (constant? x var)
-  (or (number? x)
-      (and (variable? x) (not (same-variable? x var)))
-      (and (sum? x)
-           (constant? (addend x) var)
-           (constant? (augend x) var))
-      (and (product? x)
-           (constant? (multiplier x) var)
-           (constant? (multiplicand x) var))
-      (and (exponentiation? x)
-           (constant? (base x) var)
-           (constant? (exponent x) var))))
-
-(define (make-exponentiation b e)
-  (cond ((=number? e 0) 1)
-        ((=number? e 1) b)
-        ((=number? b 0) 0)
-        ((and (number? b) (number? e)) (expt b e))
-        (else (list '** b e))))
-        
-
-(define (exponentiation? x) (and (pair? x) (eq? (car x) '**)))
-(define (base e) (cadr e))
-(define (exponent e) (caddr e))
-
-(define (deriv exp var)
-  (cond ((number? exp) 0)
-        ((variable? exp) (if (same-variable? exp var) 1 0))
-        ((sum? exp) (make-sum (deriv (addend exp) var)
-                              (deriv (augend exp) var)))
-        ((product? exp)
-         (make-sum
-          (make-product (multiplier exp)
-                        (deriv (multiplicand exp) var))
-          (make-product (deriv (multiplier exp) var)
-                        (multiplicand exp))))
-        ((exponentiation? exp)
-         (if (constant? (exponent exp) var)
-             (make-product (make-product (exponent exp)
-                                         (make-exponentiation (base exp)
-                                                              (make-sum
-                                                               (exponent exp)
-                                                               -1)))
-                           (deriv (base exp) var))
-             (error "non-constant exponents not yet supported: DERIV" exp)))
-        (else
-         (error "unknown expression type: DERIV" exp))))

chapter-2/ex-2.57.scm

@@ -1,120 +0,0 @@
-#lang sicp
-
-; For these exercises, where I'm adding extra functionality to the deriv
-; system. I chose to build each new feature off of the results of the previous
-; exercises, rather than the unmodified code.
-; This might make the solutions a bit more complicated than they have to be
-
-(define (variable? x) (symbol? x))
-(define (same-variable? v1 v2)
-  (and (variable? v1) (variable? v2) (eq? v1 v2)))
-
-(define (=number? exp num) (and (number? exp) (= exp num)))
-
-(define (not-number? x) (not (number? x)))
-
-(define (filter predicate sequence)
-  (cond ((null? sequence) nil)
-        ((predicate (car sequence))
-         (cons (car sequence)
-               (filter predicate (cdr sequence))))
-        (else (filter predicate (cdr sequence)))))
-
-; folds the constants of the top-level expression
-; e.g. (+ 2 3 x 5) becomes (+ 10 x)
-;      (+ x y z) -> (+ x y z)
-;      (* 2 x 0 3) -> 0
-;      (+ 3 -3 x) -> x
-(define (fold exp)
-  (if (and (not (sum? exp)) (not (product? exp)))
-      exp ; if you don't know how to fold the exp, just leave it
-      (let* ((op (car exp))
-             (consts (filter number? (cdr exp)))
-             (rest (filter not-number? (cdr exp)))
-             (folded-const (if (eq? op '+)
-                               (apply + consts)
-                               (apply * consts)))
-             (args (cond ((and (eq? op '*) (= folded-const 0)) '(0))
-                         ((and (eq? op '*) (= folded-const 1)) rest)
-                         ((and (eq? op '+) (= folded-const 0)) rest)
-                         (else (append (list folded-const) rest)))))
-        (cond ((and (eq? op '+) (= (length args) 0)) 0)
-              ((and (eq? op '*) (= (length args) 0)) 1)
-              ((= (length args) 1) (car args))
-              (else (append (list op) args))))))
-
-; make-sum and make-product will be changed so that any arguments which are
-; sums themselves will be spliced into the list, and all numbers will be placed
-; in the front and folded
-(define (make-sum a1 a2)
-  ; l1 and l2 are lists to be spliced, if they're not sums, we make them lists
-  ; of a list, so effectively, they don't get spliced
-  (let ((l1 (if (sum? a1) (cdr a1) (list a1)))
-        (l2 (if (sum? a2) (cdr a2) (list a2))))
-    (fold (append '(+) l1 l2))))
-
-(define (make-product m1 m2)
-  (let ((l1 (if (product? m1) (cdr m1) (list m1)))
-        (l2 (if (product? m2) (cdr m2) (list m2))))
-    (fold (append '(*) l1 l2))))
-
-(define (sum? x) (and (pair? x) (eq? (car x) '+)))
-(define (addend s) (cadr s))
-(define (augend s) (if (= (length s) 3)
-                       (caddr s)
-                       (cons '+ (cddr s))))
-(define (product? x) (and (pair? x) (eq? (car x) '*)))
-(define (multiplier p) (cadr p))
-(define (multiplicand p) (if (= (length p) 3)
-                             (caddr p)
-                             (cons '* (cddr p))))
-
-; for the purposes of our exponentiation exercise, we need to determine whether
-; the exponent is constant so that we can apply the rule correctly
-(define (constant? x var)
-  (or (number? x)
-      (and (variable? x) (not (same-variable? x var)))
-      (and (sum? x)
-           (constant? (addend x) var)
-           (constant? (augend x) var))
-      (and (product? x)
-           (constant? (multiplier x) var)
-           (constant? (multiplicand x) var))
-      (and (exponentiation? x)
-           (constant? (base x) var)
-           (constant? (exponent x) var))))
-
-(define (make-exponentiation b e)
-  (cond ((=number? e 0) 1)
-        ((=number? e 1) b)
-        ((=number? b 0) 0)
-        ((and (number? b) (number? e)) (expt b e))
-        (else (list '** b e))))
-        
-
-(define (exponentiation? x) (and (pair? x) (eq? (car x) '**)))
-(define (base e) (cadr e))
-(define (exponent e) (caddr e))
-
-(define (deriv exp var)
-  (cond ((number? exp) 0)
-        ((variable? exp) (if (same-variable? exp var) 1 0))
-        ((sum? exp) (make-sum (deriv (addend exp) var)
-                              (deriv (augend exp) var)))
-        ((product? exp)
-         (make-sum
-          (make-product (multiplier exp)
-                        (deriv (multiplicand exp) var))
-          (make-product (deriv (multiplier exp) var)
-                        (multiplicand exp))))
-        ((exponentiation? exp)
-         (if (constant? (exponent exp) var)
-             (make-product (make-product (exponent exp)
-                                         (make-exponentiation (base exp)
-                                                              (make-sum
-                                                               (exponent exp)
-                                                               -1)))
-                           (deriv (base exp) var))
-             (error "non-constant exponents not yet supported: DERIV" exp)))
-        (else
-         (error "unknown expression type: DERIV" exp))))

chapter-2/ex-2.58.scm

@@ -1,272 +0,0 @@
-#lang sicp
-
-; Thoughts before the exercise:
-; The first thing that I think might be an issue here is unnecessarily nested
-; expressions:
-; example: (((1 + 2 * 3))). We didn't have to think about these when we were simply
-; using Lisp notation, since every list was basically guarranteed to have an
-; operator. In our new case, every list with a length > 1 is going to have to
-; have an operator, but we need a way to deal naturally with expressions of the
-; form (x), where the result of the expression is obviously x.
-
-; One idea would be to have a function that tries to access the innermost list.
-; And then use it throughout all the other functions. But this would be quite
-; painful. A better idea might be to consider this list to be a new kind of
-; expression, called a grouping, we could have a predicate "grouping?", a
-; selector "group-mem", and a constructor "group" (but there's no reason to ever
-; use the constructor.)
-
-; Okay, once we know how to deal with those, everything else should be clear: a
-; sum is simply a list that contains +, a product is a list that contains * but
-; not +, an exponentiation is a list which contains only the ** operator
-; (speaking at the top level for all of these, of course).
-
-; It's clear how to construct a sum, it's also clear how to get the addend and
-; augend, and construction, in essence, is not complicated. However, if we want
-; to try and keep the expressions somewhat simplified, like we did in previous
-; exercises, we may need to do more work on the constructors.
-
-(define op-order '(+ * **))
-
-(define (list-index lst elem)
-  (define (li-rec lst elem index)
-    (cond ((null? lst) -1)
-          ((eq? (car lst) elem) index)
-          (else (li-rec (cdr lst) elem (+ index 1)))))
-  (li-rec lst elem 0))
-
-;compares precedence of ops
-(define (lower-or-eq-op op1 op2)
-  (<= (list-index op-order op1)
-      (list-index op-order op2)))
-
-; finds the-top-level op for an expression list:
-; e.g. (1 + (2 * 4) * 3) => +
-(define (top-op exp)
-  (define (top-op-rec exp op-order)
-    (cond ((null? op-order) nil)
-          ((memq (car op-order) exp) (car op-order))
-          (else (top-op-rec exp (cdr op-order)))))
-  (top-op-rec exp op-order))
-
-(define (make-group exp)
-  (list exp))
-
-; a group is just a list of length 1
-(define (group? exp)
-  (and (pair? exp) (null? (cdr exp))))
-
-(define (degroup exp)
-  (car exp))
-
-; not the real deconstructor, but very useful
-(define (degroup-repeated exp)
-  (if (group? exp)
-      (degroup-repeated (degroup exp))
-      exp))
-
-; We're gonna be doing this, a lot
-; turns a list such as (1 (2 * 4) 3) into (1 + (2 * 4) + 3)
-(define (splice-op arglist op)
-  (cond ((null? arglist) nil) ; 0 args
-        ((null? (cdr arglist)) arglist) ; 1 arg
-        (else (cons (car arglist)
-                    (cons op
-                          (splice-op (cdr arglist) op))))))
-
-; This does the opposite, assumes op is the top-op of the expression
-; eg. (1 + 2 * 4 + 3) => (1 (2 * 4) 3)
-(define (extract-op exp op)
-  (cond ((null? exp) nil)
-        ((null? (cdr exp)) exp)
-        ((null? (cddr exp)) (error "Extract-op from two-member list" exp))
-        ((not (memq (cadr exp) op-order)) (error "Extract-op, second element not an op" exp))
-        ((eq? (cadr exp) op) (cons (car exp)
-                                   (extract-op (cddr exp) op)))
-        (else (cons (grab-subexp exp op)
-                    (extract-op (drop-subexp exp op))))))
-
-; two helper functions for extract-op, extract a beginning subexpression, which uses a
-; higher precedence op
-; e.g. exp. (2 * 4 + 3 + 5), op: +
-; (grab-subexp exp op) => (2 * 4)
-; (drop-subexp exp op) => (3 + 5)
-;
-; exp. (2 * 4 + 3), op: +
-; (grab-subexp exp op) => (2 * 4)
-; (drop-subexp exp op) => (3)
-;
-; exp. (2 * 4), op: +
-; (grab-subexp exp op) => (2 * 4)
-; (drop-subexp exp op) => ()
-(define (grab-subexp exp op)
-  (if (or (null? exp) (eq? op (car exp)))
-      nil
-      ; if we reach the end of the list, or the top-level op, we stop adding elements
-      (cons (car exp)
-            (grab-subexp (cdr exp) op))))
-
-(define (drop-subexp exp op)
-  (let ((list-from-op (memq op exp)))
-    (if (not list-from-op)
-        nil
-        (cdr list-from-op))))
-
-; accepts a complex expression containing at least one operations
-; removes parentheses around subexpressions which use an operator with higher
-; precedence
-(define (remove-parens list op)
-  (cond ((null? list) nil)
-        ((or (number? (car list))
-             (variable? (car list))
-             ; we don't want to remove parentheses around ops of the same precedence
-             ; since we did that while extracting argument lists. And if our operation
-             ; is not associative (e.g. **) this could cause an error
-             (lower-or-eq-op (top-op (car list)) op))
-         (cons (car list) (remove-parens (cdr list) op)))
-        ; in any other case, it's either a grouping, or a higher-precedence op
-        ; and we can get rid of the parens
-        (else (append (car list) (remove-parens (cdr list) op)))))
-
-(define (variable? x) (symbol? x))
-(define (same-variable? v1 v2)
-  (and (variable? v1) (variable? v2) (eq? v1 v2)))
-
-(define (=number? exp num) (and (number? exp) (= exp num)))
-
-(define (not-number? x) (not (number? x)))
-
-(define (filter predicate sequence)
-  (cond ((null? sequence) nil)
-        ((predicate (car sequence))
-         (cons (car sequence)
-               (filter predicate (cdr sequence))))
-        (else (filter predicate (cdr sequence)))))
-
-; instead of the "fold" function in the previous exercise, here we have several
-; "optimize" functions for arglists
-(define (optimize-+ args)
-  (let* ((consts (filter number? args))
-         (rest (filter not-number? args))
-         (folded-const (apply + consts)))
-    (if (= folded-const 0)
-        rest
-        (append (list folded-const) rest))))
-
-(define (optimize-* args)
-  (let* ((consts (filter number? args))
-         (rest (filter not-number? args))
-         (folded-const (apply * consts)))
-    (cond ((= folded-const 1) rest)
-          ((= folded-const 0) '(0))
-          (else (append (list folded-const) rest)))))
-
-(define (optimize-** args)
-  (cond ((null? args) (error "Empty arg list for ** in optimize-**"))
-        ((null? (cdr args)) args)
-        (else
-         (let* ((new-args (cons (car args) ; if len(args)>=2, we first try to
-                                ; compute the right hand side recursively
-                                ; if afterwards len(args)==2, we try that too
-                                (optimize-** (cdr args))))
-                (len=2 (null? (cddr new-args)))
-                (fst   (car new-args))
-                (snd   (cadr new-args)))
-           (cond ((and len=2 (number? fst) (number? snd)) ; both constant
-                  (list (expt (car new-args) (cadr new-args))))
-                 ((and len=2 (=number? snd 1))
-                  (list fst))
-                 (else new-args))))))
-
-(define (make-op op x1 x2)
-  (let* ((ux1 (degroup-repeated x1)) ; now we know our args are either simple nums/vars or
-         (ux2 (degroup-repeated x2)) ; they're an operation (+,*,**)
-         (exp->arglist
-          (lambda (exp) ; as long as our subexpression: exp. is not an operation of the exact
-            ; same type as the one we're creating, the list of extracted args
-            ; should just look like (exp). Otherwise, we need to extract the
-            ; operators from the list
-            ; e.g. op=+, x1 = (2 + 3 + 2 * 4) -> result=(2 3 (2 * 4))
-            ;            x2 = (2 * 4) -> result=((2 * 4))
-            ; then we simply append the lists
-            (if (or (variable? exp)
-                    (number? exp)
-                    (not (eq? op (top-op exp))))
-                (list exp)
-                (extract-op exp op))))
-         (arglist1 (if (and (eq? op '**) ; if both the op we're making, and the left-hand side
-                            (exponentiation? ux1)) ; are an exponentiation, we need to simply
-                       (list ux1) ; parenthesise the left-hand side, don't extract args,
-                       (exp->arglist ux1))) ; because ** is right-associative
-         (arglist2 (exp->arglist ux2)) 
-         (args (append arglist1 arglist2))
-         (opt-args (cond ((eq? op '+)  (optimize-+  args))
-                         ((eq? op '*)  (optimize-*  args))
-                         ((eq? op '**) (optimize-** args)))))
-    ; keep in mind, after this step ** must have at least 1 argument,
-    ; +,* can have 0
-    (cond ((and (eq? op '+) (= (length opt-args) 0)) 0)
-          ((and (eq? op '*) (= (length opt-args) 0)) 1)
-          ((= (length opt-args) 1) (car opt-args))
-          (else (remove-parens (splice-op opt-args op) op)))))
-
-(define (make-sum a1 a2)
-  (make-op '+ a1 a2))
-
-(define (make-product m1 m2)
-  (make-op '* m1 m2))
-
-(define (sum? x) (and (pair? x) (eq? (top-op x) '+)))
-; when we split the list using grab/drop-subexp, we might get a list of length
-; 1 on either end
-(define (addend s) (degroup-repeated (grab-subexp s '+)))
-(define (augend s) (degroup-repeated (drop-subexp s '+)))
-
-(define (product? x) (and (pair? x) (eq? (top-op x) '*)))
-(define (multiplier p) (degroup-repeated (grab-subexp p '*)))
-(define (multiplicand p) (degroup-repeated (drop-subexp p '*)))
-
-; for the purposes of our exponentiation exercise, we need to determine whether
-; the exponent is constant so that we can apply the rule correctly
-(define (constant? x var)
-  (or (number? x)
-      (and (variable? x) (not (same-variable? x var)))
-      (and (sum? x)
-           (constant? (addend x) var)
-           (constant? (augend x) var))
-      (and (product? x)
-           (constant? (multiplier x) var)
-           (constant? (multiplicand x) var))
-      (and (exponentiation? x)
-           (constant? (base x) var)
-           (constant? (exponent x) var))))
-
-(define (make-exponentiation b e)
-  (make-op '** b e))
-
-(define (exponentiation? x) (and (pair? x) (eq? (top-op x) '**)))
-(define (base e) (car e))
-(define (exponent e) (caddr e))
-
-(define (deriv exp var)
-  (cond ((number? exp) 0)
-        ((variable? exp) (if (same-variable? exp var) 1 0))
-        ((sum? exp) (make-sum (deriv (addend exp) var)
-                              (deriv (augend exp) var)))
-        ((product? exp)
-         (make-sum
-          (make-product (multiplier exp)
-                        (deriv (multiplicand exp) var))
-          (make-product (deriv (multiplier exp) var)
-                        (multiplicand exp))))
-        ((exponentiation? exp)
-         (if (constant? (exponent exp) var)
-             (make-product (make-product (exponent exp)
-                                         (make-exponentiation (base exp)
-                                                              (make-sum
-                                                               (exponent exp)
-                                                               -1)))
-                           (deriv (base exp) var))
-             (error "non-constant exponents not yet supported: DERIV" exp)))
-        (else
-         (error "unknown expression type: DERIV" exp))))

chapter-2/ex-2.59.scm

@@ -1,15 +0,0 @@
-#lang sicp
-
-(define (element-of-set? x set)
-  (cond ((null? set) false)
-	((equal? x (car set)) true)
-	(else (element-of-set? x (cdr set)))))
-
-; we will simply adjoin elements of set1 to set2 if they are not there
-; and drop them if they are there
-(define (union-set set1 set2)
-  (cond ((null? set1) set2)
-	((null? set2) set1)
-	((element-of-set? (car set1) set2)
-	 (union-set (cdr set1) set2))
-	(else (union-set (cdr set1) (cons (car set1) set2)))))

chapter-2/ex-2.60.scm

@@ -1,24 +0,0 @@
-#lang sicp
-
-; element-of-set? is the exact same
-; O(n)
-(define (element-of-set? x set)
-  (cond ((null? set) false)
-	((equal? x (car set)) true)
-	(else (element-of-set? x (cdr set)))))
-
-; O(1)
-(define (adjoin-set x set)
-  (cons x set)) ; we don't have to check anymore
-
-; O(n), where n is the length of set1
-(define (union-set set1 set2)
-  (append set1 set2))
-
-; intersection-set can still be the exact same
-; O(n^2)
-(define (intersection-set set1 set2)
-  (cond ((or (null? set1) (null? set2)) '())
-	((element-of-set? (car set1) set2)
-	 (cons (car set1) (intersection-set (cdr set1) set2)))
-	(else (intersection-set (cdr set1) set2))))

chapter-2/ex-2.61.scm

@@ -1,7 +0,0 @@
-#lang sicp
-
-(define (adjoin-set x set)
-  (cond ((null? set) (list x))
-	((< x (car set)) (cons x set))
-	((= x (car set)) set)
-	((> x (car set)) (cons (car set) (adjoin-set x (cdr set))))))

chapter-2/ex-2.62.scm

@@ -1,11 +0,0 @@
-#lang sicp
-
-(define (union-set set1 set2)
-  (cond ((null? set1) set2)
-	((null? set2) set1)
-	((< (car set1) (car set2)) (cons (car set1)
-					 (union-set (cdr set1) set2)))
-	((= (car set1) (car set2)) (cons (car set1)
-					 (union-set (cdr set1) (cdr set2))))
-	((> (car set1) (car set2)) (cons (car set2)
-					 (union-set set1 (cdr set2))))))

chapter-2/ex-2.63.txt

@@ -1,16 +0,0 @@
-a)
-From my understanding, yes, the lists produced are always going to be equal?
-given the same tree
-
-b)
-No, they don't, remember than when we `append` two lists, the cons cells for
-the first list have to all be reconstructed, which is an additional O(n)
-steps, where n is len(first-list).
-
-This means that when we break up a tree in (tree->list-1 tree) T(n) = T(n/2) +
-O(n) + T(n/2)
-
-tree->list-2 has one cons operation, which is constant, for each entry, which
-means the order of growth is O(n)
-
-On the other hand, tree->list-1 has order of growth: O(n log n)

chapter-2/ex-2.64.txt

@@ -1,22 +0,0 @@
-a)
-partial-tree takes a list elts, and n, a number of starting elements which it
-will process, it arranges these n elements into a tree and returns a list with
-2 elements. The first is a tree of the first n elements, the second is a list
-of the remaining elements. The arrangement is done by making a tree out of
-(n-1)/2 elements recursively, then adding the one element at the start of the
-remainder-list as the current entry, then taking the other half of the n
-elements, and recursively arranging them as well.
-
-(list->tree '(1 3 5 7 9 11))
-==
-         5
-      /     \
-     1       9
-      \     / \
-       3   7  11
-
-b)
-Since only the top-level list has its length calculated O(n), while all the
-lower ones have theirs calculated in constant time. And in general, every
-specific call of partial-tree has a number of constant operations, the total
-would be O(n)

chapter-2/ex-2.65.scm

@@ -1,101 +0,0 @@
-#lang sicp
-
-; the helper functions:
-
-(define (entry tree) (car tree))
-(define (left-branch tree) (cadr tree))
-(define (right-branch tree) (caddr tree))
-(define (make-tree entry left right)
-  (list entry left right))
-
-(define (element-of-set? x set)
-  (cond ((null? set) false)
-        ((= x (entry set)) true)
-        ((< x (entry set))
-         (element-of-set? x (left-branch set)))
-        ((> x (entry set))
-         (element-of-set? x (right-branch set)))))
-
-(define (adjoin-set x set)
-  (cond ((null? set) (make-tree x '() '()))
-        ((= x (entry set)) set)
-        ((< x (entry set))
-         (make-tree (entry set)
-                    (adjoin-set x (left-branch set))
-                    (right-branch set)))
-        ((> x (entry set))
-         (make-tree (entry set) (left-branch set)
-                    (adjoin-set x (right-branch set))))))
-
-(define (tree->list-2 tree)
-  (define (copy-to-list tree result-list)
-    (if (null? tree)
-        result-list
-        (copy-to-list (left-branch tree)
-                      (cons (entry tree)
-                            (copy-to-list
-                             (right-branch tree)
-                             result-list)))))
-  (copy-to-list tree '()))
-
-(define tree->list tree->list-2)
-
-(define (list->tree elements)
-  (car (partial-tree elements (length elements))))
-
-(define (partial-tree elts n)
-  (if (= n 0)
-      (cons '() elts)
-      (let ((left-size (quotient (- n 1) 2)))
-        (let ((left-result
-               (partial-tree elts left-size)))
-          (let ((left-tree (car left-result))
-                (non-left-elts (cdr left-result))
-                (right-size (- n (+ left-size 1))))
-            (let ((this-entry (car non-left-elts))
-                  (right-result
-                   (partial-tree
-                    (cdr non-left-elts)
-                    right-size)))
-              (let ((right-tree (car right-result))
-                    (remaining-elts
-                     (cdr right-result)))
-                (cons (make-tree this-entry
-                                 left-tree
-                                 right-tree)
-                      remaining-elts))))))))
-
-
-; the exercise itself
-
-(define (union-olist set1 set2)
-  (cond ((null? set1) set2)
-        ((null? set2) set1)
-        ((< (car set1) (car set2)) (cons (car set1)
-                                         (union-olist (cdr set1) set2)))
-        ((= (car set1) (car set2)) (cons (car set1)
-                                         (union-olist (cdr set1) (cdr set2))))
-        ((> (car set1) (car set2)) (cons (car set2)
-                                         (union-olist set1 (cdr set2))))))
-
-(define (intersection-olist set1 set2)
-  (if (or (null? set1) (null? set2))
-      '()
-      (let ((x1 (car set1)) (x2 (car set2)))
-        (cond ((= x1 x2)
-               (cons x1 (intersection-olist (cdr set1)
-                                            (cdr set2))))
-              ((< x1 x2)
-               (intersection-olist (cdr set1) set2))
-              ((< x2 x1)
-               (intersection-olist set1 (cdr set2)))))))
-
-(define (union-set set1 set2)
-  (list->tree
-   (union-olist (tree->list set1)
-                (tree->list set2))))
-
-(define (intersection-set set1 set2)
-  (list->tree
-   (intersection-olist (tree->list set1)
-                       (tree->list set2))))

chapter-2/ex-2.66.scm

@@ -1,19 +0,0 @@
-#lang sicp
-
-(define (entry tree) (car tree))
-(define (left-branch tree) (cadr tree))
-(define (right-branch tree) (caddr tree))
-(define (make-tree entry left right)
-  (list entry left right))
-
-(define (key record)
-  (car record))
-
-(define (lookup given-key set-of-records)
-  (cond ((null? set-of-records) false)
-        ((= given-key (key (entry set-of-records)))
-         (entry set-of-records))
-        ((< given-key (key (entry set-of-records)))
-         (lookup given-key (left-branch set-of-records)))
-        ((> given-key (key (entry set-of-records)))
-         (lookup given-key (right-branch set-of-records)))))