SICP习题笔记（第一章）

最新推荐文章于 2017-07-26 18:18:34 发布

懒懒的好男人

最新推荐文章于 2017-07-26 18:18:34 发布

阅读量409

点赞数 1

CC 4.0 BY-SA版权

分类专栏： SICP 文章标签： scheme sicp 作业习题

本文链接：https://blog.youkuaiyun.com/u014708761/article/details/71025845

SICP 专栏收录该内容

1 篇文章

订阅专栏

本文解析了Scheme编程语言中的多个经典习题，包括Ackermann函数、Pascal三角形、快速幂运算、快速乘法等，提供了递归及迭代两种实现方式，并深入探讨了Fibonacci数列的对数级复杂度算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前面九题是熟悉用于熟悉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)))))