sicp习题2.2节尝试解答

习题2.17,直接利用list-ref和length过程

(define (last - pair items)
  (list (list - ref items ( -  (length items)  1 ))))

习题2.18,采用迭代法

(define (reverse - list items)
  (define (reverse - iter i k)
    ( if  ( null ?  i) k (reverse - iter (cdr i) (cons (car i) k))))
  (reverse - iter items ()))

习题2.20，如果两个数的奇偶相同，那么他们的差模2等于0，根据这一点可以写出：

(define (same - parity a . b)
  (define (same - parity - temp x y)
  (cond (( null ?  y) y)
        (( =  (remainder ( -  (car y) x)  2 )  0 )
         (cons (car y) (same - parity - temp x (cdr y))))
        ( else
           (same - parity - temp x (cdr y)))))
  (cons a (same - parity - temp a b)))

利用了基本过程remainder取模

习题2.21，递归方式：

(define (square - list items)
  ( if  ( null ?  items)
      items 
      (cons (square (car items)) (square - list (cdr items)))))

利用map过程：

(define (square - list items)
  (map square items))

习题2.23，这与ruby中的each是一样的意思，将操作应用于集合的每个元素：

(define ( for - each proc items)
  (define ( for - each - temp proc temp items)
  ( if  ( null ?  items)
      #t
      ( for - each - temp proc (proc (car items)) (cdr items))))
  ( for - each - temp proc  0  items))

最后返回true

习题2.24，盒子图就不画了，麻烦，解释器输出：

Welcome to DrScheme, version  360 .
Language: Standard (R5RS).
>  (list  1  (list  2  (list  3   4 )))
( 1  ( 2  ( 3   4 )))

树形状应当是这样

               . 
              /\
             /  \
            1    .
                 /\
                /  \
               2    .
                    /\
                   /  \
                  3    4

习题2.25，
第一个list可以表示为(list 1 3 (list 5 7) 9)
因此取7的操作应当是：

(car (cdr (car (cdr (cdr (list  1   3  (list  5   7 )  9 ))))))

第二个list表示为:(list (list 7))
因此取7操作为：

(car (car (list (list  7 ))))

第三个list可以表示为：

(list  1  (list  2  (list  3  (list  4  (list  5  (list  6   7 ))))))

因此取7的操作为：

(define x (list  1  (list  2  (list  3  (list  4  (list  5  (list  6   7 )))))))
(car (cdr (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr x))))))))))))

够恐怖！-_-

习题2.26，纯粹的动手题，就不说了
习题2.27，在reverse的基础上进行修改，同样采用迭代，比较难理解：

(define (deep - reverse x)
  (define (reverse - iter rest result)
    (cond ((null? rest) result)
          (( not  (pair? (car rest)))
           (reverse - iter (cdr rest)
                 (cons (car rest) result)))
          ( else
           (reverse - iter (cdr rest)
                 (cons (deep - reverse (car rest)) result)))
           ))
  (reverse - iter x ()))

习题2.28，递归，利用append过程就容易了：

(define (finge x)
  (cond ((pair? x) (append (finge (car x)) (finge (cdr x))))
        ((null? x) ())
        ( else  (list x))))

习题2.29，这一题很明显出来的二叉活动体也是个层次性的树状结构
1）很简单，利用car,cdr

(define (left - branch x)
  (car x))
(define (right - branch x)
  (car (cdr x)))
(define (branch - length b)
  (car b))
(define (branch - structure b)
  (car (cdr b)))

2）首先需要一个过程用于求解分支的总重量：

(define (branch - weight branch)
  (let ((structure (branch - structure branch)))
    ( if  ( not  (pair? structure))
        structure
        (total - weight structure))))
(define (total - weight mobile)
  ( +  (branch - weight (left - branch mobile))
     (branch - weight (right - branch mobile))))

利用这个过程写出balanced?过程：

(define (torque branch)
  ( *  (branch - length branch) (branch - weight branch)))
(define (balanced? mobile)
  ( =  (torque (left - branch mobile))
     (torque (right - branch mobile))))

3)选择函数和定义函数提供了一层抽象屏蔽，其他函数都是建立在这两个基础上，因此需要改变的仅仅是selector函数：

(define (right - branch mobile) (cdr mobile))
(define (branch - structure branch) (cdr branch))

习题2.30：

(define (square - tree tree)
  (cond ((null? tree) tree)
        (( not  (pair? tree)) (square tree))
        ( else
           (cons (square - tree (car tree)) (square - tree (cdr tree))))))
(define (square - tree2 tree)
  (map ( lambda (x)
         ( if  (pair? x)
             (square - tree x)
             (square x))) tree))

习题2.31，进一步抽象出map-tree，与map过程类似，将proc过程作用于树的每个节点：

(define (tree - map proc tree)
  (cond ((null? tree) tree)
        (( not  (pair? tree)) (proc tree))
        ( else
           (cons (tree - map proc (car tree)) (tree - map proc (cdr tree))))))
(define (square - tree3 tree)
  (tree - map square tree))

习题2.32，通过观察，rest总是cdr后的子集，比如对于(list 1 2 3)，连续cdr出来的是：
(2 3)
(3)
()
其他的5个子集应该是car结果与这些子集组合的结果，因此：

(define (subsets s)
  ( if  (null? s)
      (list s)
      (let ((rest (subsets (cdr s))))
        (append rest (map ( lambda (x) (cons (car s) x)) rest)))))