SICP学习笔记 第一章 （1.2）

递归计算过程（recursive process）：这种类型的计算过程由一个推迟执行的运算链条刻画。

迭代计算过程（iterative process）：其状态可以用固定数目的状态变量描述。与此同时，又存在一套固定规则，描述了计算过程从一个状态到下一个状态转换时，变量的更新方式，还有一个结束检测，描述计算过程应该终止的条件。

范例：换零钱

(define (count-change amount)
    (cc amount 5))
(define (cc amount kinds-of-coins)
    (cond ((= amount 0) 1)
           ((or (< amount 0) (= kinds-of-coins 0)) 0)
           (else (+ (cc amount
                        (- kinds-of-coins 1))
                    (cc (- amount
                           (first-denomination kinds-of-coins))
                        kinds-of-coins)))))
(define (first-denomination kinds-of-coins)
    (cond ((= kinds-of-coins 1) 1)
           (= kinds-of-coins 2) 5)
           (= kinds-of-coins 3) 10)
           (= kinds-of-coins 4) 25)
           (= kinds-of-coins 5) 50)))

部分习题：

exercise 1.9

(+ 4 5)
(inc (+ 3 5))
(inc (inc (+ 2 5)))
(inc (inc (inc (+ 1 5))))
(inc (inc (inc (inc (+ 0 5)))))
(inc (inc (inc (inc 5))))
(inc (inc (inc 6)))
(inc (inc 7))
(inc 8)
9

(+ 4 5)
(+ 3 6)
(+ 2 7)
(+ 1 8)
(+ 0 9)
9

exercise 1.11

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

;iterative process
(define (f n)
    (define (f-iter a b c n)
        (if (= n 0)
        a
        (f-iter b
                c
                (+ (* 3 a)
                   (* 2 b)
                   c)
                (- n 1)))
    (f-iter 0 1 2 n))

 exercise 1.12

需要输入两个参数，代表第几行第几个元素，索引从0开始，则第一个元素表示为 (pascal 0 0)。

(define (pascal row col)
    (cond ((= col 0) 1)
          ((= col row) 1)
          ((> col row) (display "col can't larger then row"))    
          (else (+ (pascal (- row 1)
                           (- col 1))
                   (pascal (- row 1)
                           col)))))

 exercise 1.15

a) p将被使用5次，代换模型如下。

(sine 12.15)
(p (sine 4.05))
(p (p (sine 1.35)))
(p (p (p (sine 0.45))))
(p (p (p (p (sine 0.15)))))
(p (p (p (p (p (sine 0.05))))))

 exercise 1.16

(define (fast-expt b n)
    (define (fast-expt-iter b n a)
         (cond ((= n 0) a)
               ((even? n) (fast-expt-iter (square b)
                                          (/ n 2)
                                          a))
               (else (fast-expt-iter b
                                     (- n 1)
                                     (* a b)))))
    (fast-expt-iter b n 1))

 exercise 1.17

(define (double x)
    (+ x x))
(define (halve x)
    (/ x 2))
(define (fast-multi a b)
    (cond ((= b 0) 0)
          ((even? b) (fast-multi (double a) (halve b)))
          (else (+ a (fast-multi a (- b 1))))))

 exercise 1.18

(define (double x)
    (+ x x))
(define (halve x)
    (/ x 2))
(define (fast-multi a b)
    (define (fast-multi-iter a b product)
        (cond ((= b 0) product)
              ((even? b) (fast-multi-iter (double a) (halve b) product))
              (else (fast-multi-iter a (- b 1) (+ a product)))))
    (fast-multi-iter a b 0))

 exercise 1.19

(define (fib n)
    (fib-iter 1 0 0 1 n))
(define (fib-iter a b p q count)
    (cond ((= count 0) b)
          ((even? count) (fib-iter a 
                                   b
                                   (+ (square p) (square q))
                                   (+ (* 2 p q) (square q))
                                   (/ count 2)))
          (else (fib-iter (+ (* b q) (* a q) (* a p))
                          (+ (* b p) (* a q))
                          p
                          q
                          (- count 1)))))

  exercise 1.20

;normal order evaluate
(gcd 206 40)
(if (= 40 0)
    206
    (gcd 40 (remainder 206 40)))
(gcd 40 (remainder 206 40))
(if (= (remainder 206 40) 0)
    40
    (gcd (remainder 206 40) (remainder 40 (remainder 206 40))))
......


;application order evaluate
(gcd 206 40)
(gcd 40 6)
(gcd 6 4)
(gcd 4 2)
(gcd 2 0)
2