SICP Exercise 1

10                                  ; 10
(+ 5 3 4)                           ; 12
(- 9 1)                             ; 8
(/ 6 2)                             ; 3
(+ (* 2 4) (- 4 6))                 ; 6
(define a 3)                        ;
(define b (+ a 1))                  ;
(+ a b (* a b))                     ; 19
(= a b)                             ; #f
(if (and (> b a) (< b (* a b)))     ; 4
    b
    a)

(cond ((= a 4) 6)                   ; 16
      ((= b 4) (+ 6 7 a))
      (else 25))

(+ 2 (if (> b a) b a))              ; 6

(* (cond ((> a b) a)                ; 16
         ((< a b) b)
         (else -1))
   (+ a 1))

(define (square x) (* x x))
(define (squaresum x y) (+ (square x) (square y)))
(define (sumgreater a b c)
  (cond ((and (>= a c) (>= b c)) (squaresum a b))
        ((and (>= a b) (>= c b)) (squaresum a c))
        ((and (>= b a) (>= c a)) (squaresum b c))))

(define (cube x)
  (cube-iter 1.0 x))
(define (cube-iter guess x)
  (if (good-enough? guess x)
      guess
      (cube-iter (improve guess x) x)))
(define (good-enough? guess x)
  (= (improve guess x) guess))
(define (improve guess x)
  (/ (+ (/ x
           (* guess guess))
        (* 2 guess))
     3))

(define (f n)
  (if (< n 3)
      n
      (+ (f (- n 1))
         (* 2 (f (- n 2)))
         (* 3 (f (- n 3))))))

(define (f n)
  (if (< n 3)
      n
      (f-iter 2 1 0 n)))
(define (f-iter a b c n)
  (define t (+ a (* 2 b) (* 3 c)))
  (if (= 3 n)
      t
      (f-iter t a b (- n 1))))

(define (* a b)
  (cond ((= b 0) 0)
        ((even? b) (* (double a) (halve b)))
        (else (+ (* a (- b 1)) a))))

(define (double a) (+ a a))
(define (halve a) (floor (/ a 2)))
(define (* a b)
  (define (*-iter r a b)
    (cond ((= b 0) 0)
            ((even? b) (*-iter r (double a) (halve b)))
            (else (*-iter (+ r a) a (- b 1)))))
  (*-iter 0 a b))

(define (gcd a b)
  (if (= b 0)
      a
      (gcd b (remainder a b))))

(gcd 206 40)
(gcd 40 (remainder 206 40))
  -> 1 times
(gcd (remainder 206 40) (remainder 40 (remainder 206 40)))
  -> 2
(gcd (remainder 40 (remainder 206 40))
     (remainder (remainder 206 40) (remainder 40 (remainder 206 40))))
  -> 4
(gcd (remainder (remainder 206 40) (remainder 40 (remainder 206 40)))
     (remainder
      (remainder 40 (remainder 206 40))
      (remainder (remainder 206 40) (remainder 40 (remainder 206 40)))))
  -> 7 + 4 = 11
1 + 2 + 4 + 11 = 18

(gcd 206 40)
(gcd 40 (remainder 206 40))
(gcd 40 6)
(gcd 6 (remainder 40 6))
(gcd 6 4)
(gcd 4 (remainder 6 4))
(gcd 4 2)
(gcd 2 (remainder 4 2))
(gcd 2 0)
4

; recursive
(define (cont-frac N D k)
  (define (iter s k)
    (if (= s k)
        (/ (N k) (D k))
        (/ (N k) (+ (D k) (iter (+ s 1) k)))))
  (iter 1 k))

; iterative
(define (cont-frac-iter N D k)
  (define (iter result s)
    (if (= s 1)
        (/ (N 1) (+ (D 1) result))
        (iter (/ (N s) (+ (D s) result)) (- s 1))))
  (iter 0 k))