SICP习题笔记（第一章）

前面九题是熟悉用于熟悉scheme，不做记录
第十题Ackermann函数的展开形式，在数学课本中有介绍
1.11

  1(define (f n)                                                               
  2   (cond ((< n 3) n)                                                         
  3         (else (+ (f (- n 1))                                                
  4                  (* 2 (f (- n 2)))                                          
  5                  (* 3 (f (- n 3)))))))                                      
  6                                                                             
  7 (define (fun2 n)                                                            
  8   (f2 n 1 0 0 n))                                                           
  9 (define (f2 a b c cnt n)                                                    
 10   (if (or (= n (- cnt 1)) (< n 0))                                          
 11       a                                                                     
 12       (cond ((< cnt 3) (f2 cnt b c (+ 1 cnt) n))                            
 13             (else (f2 (+ a (* 2 b) (* 3 c)) a b 14 (+ 1 cnt) n)))))   

f函数是递归形式的计算，根据题意可以直接写出代码，fun2则是迭代形式的实现与f函数相同的功能，边界条件需谨慎

1.12
pascal三角实现简单，直接用递归实现

  1 (define (psc a b)                                                           
  2   (if (or (= a b) (= 1 b))                                                  
  3       1                                                                     
  4       (+ (psc (- a 1) b) (psc (- a 1) (- b 1)))))   

1.13
证明题，数学归纳法

1.14
递归层数较深，除此之外没什么难度
1.15
此题主要了解debug函数trace-entry即可
1.16

(define (fast-expt b n)                                                           (fast-expt-iter b n b 1))                                                     (define (even? n)                                                               
  (= (remainder n 2) 0))                                                        (define (fast-expt-iter b n x y)                                                  (cond ((= n 0) (/ (* x y) b))                                                 
        ((even? n) (fast-expt-iter b (/ n 2) (* x x) y))                        
        (else (fast-expt-iter b (- n 1) x (* b y)))                                   )) 

这是我的原始程序，不好，有点投机的感觉，而且没有充分挖掘题中所给的公式的含义，下面是修改后的

(define (fast-expt b n)
    (expt-iter b n 1))

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

1.17
与例题类似

(define (fast-mul a b)                                                          
  (cond ((= 1 a) b)                                                             
        ((even? a) (fast-mul (/ a 2) (* 2 b)))                                  
        (else (+ (fast-mul (- a 1) b) b))))  

1.18
与16题思路相同

(define (mul-iter a b)                                                          
  (mul-iter-1 a b 0))                                                           
(define (mul-iter-1 a b n)                                                      
  (cond ((= 1 a) (+ b n))                                                       
        ((even? a) (mul-iter-1 (/ a 2) (* 2 b) n))                              
        (else (mul-iter-1 (- a 1) b (+ b n))))) 

1.19
此题有意思，按照题中所给的提示，直接对比Tpq的平方和Tpq的关系可以得出转变公式，补全代码为：

(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                                                            
                   (+ (* p p) (* q q))                                          
                   (+ (* 2 p q) (* q q))                                        
                   (/ count 2)))                                                
        (else                                                                   
         (fib-iter (+ (* b q) (* a q) (* a p))                                  
                   (+ (* b p) (* a q))                                          
                   p                                                            
                   q                                                            
                   (- count 1)))))  

其实获得对数复杂度的方法可以是通过a=a+b,b=a两个公式得出变换矩阵，变换矩阵的n次方写一个logn的复杂度的程序很简单，而且比书中所给要方便理解（不明白为什么书里面搞这么复杂，难道更通用？）