SICP_2.33-2.39

#lang racket

;;;;;;;;;;;;;;;;;;;;;;;;;;;2.33
(define (accumulate op initial sequence)
  (if (null? sequence)
      initial
      (op (car sequence)
          (accumulate op initial (cdr sequence)))))

(define (my-map p sequence)
  (accumulate (lambda (x y)
                (cons (p x) y)) '() sequence))

(define (my-append seq1 seq2)
  (accumulate cons seq2 seq1))

(define (my-length sequence)
  (accumulate (lambda (x y) (+ 1 y)) 0 sequence))

;;;;;;;;;;;;test
(my-map (lambda (x) (* x x)) (list 1 2 3))

(my-append (list 1 2 3) (list 4 5 6))

(my-length (list 1 2 3 4 5))

;;;;;;;;;;;;;;;;;;;;;;;;;2.34
(define (horner-eval x coefficient-sequence)
  (accumulate (lambda (this-coeff higher-terms)
                (+ this-coeff (* x higher-terms)))
              0
              coefficient-sequence))

;;;;;;;;;;test
(horner-eval 2 (list 1 3 0 5 0 1))

;;;;;;;;;;;;;;;;;;;;;;;;2.35
(define (count-leaves tree)
  (accumulate + 0 (map (lambda (node)
                         (if (pair? node)
                             (count-leaves node)
                             1))
                       tree)))

;;;;;;;;;;;;test
(count-leaves (list '(1 2 3) '(2 3 4) 4 5))

;;;;;;;;;;;;;;;;;;;;2.36
(define (accumulate-n op init seqs)
  (if (null? (car seqs))
      '()
      (cons (accumulate op init (map car seqs))
            (accumulate-n op init (map cdr seqs)))))

;;;;;;;;;;;;test
(define seqs (list '(1 2 3) '(4 5 6) '(7 8 9) '(10 11 12)))
(accumulate-n + 0 seqs)

;;;;;;;;;;;;;;;;;;;;2.37
(define (dot-product v1 v2)
  (accumulate + 0 (map * v1 v2)))

(define (matrix-*-vector m v)
  (map (lambda (x) (dot-product x v)) m))

(define (matrix-*-matrix m n)
  (let ((n-cols (transpose n)))
    (map (lambda (m-row)
           (map (lambda (n-col)
                  (dot-product m-row n-col))
                n-cols))
         m)))

(define (transpose mat)
  (accumulate-n cons '() mat))

(define matrix1 (list '(1 2 3) '(1 9 3) '(1 3 4)))
(define matrix2 (list '(1 3 4) '(3 4 5) '(6 2 4)))
;;;;;;;;;;;;test
(dot-product (list 1 1 1) (list 1 2 3))
(matrix-*-vector (list '(1 2 3) '(1 2 3) '(1 3 3)) '(2 3 4))
(matrix-*-matrix matrix1 matrix2)

;;;;;;;;;;;;;;;;;;;2.38

(define (fold-left op initial sequence)
  (define (iter result rest)
    (if (null? rest)
        result
        (iter (op result (car rest))
              (cdr rest))))
  (iter initial sequence))

(define (fold-right op initial sequence)
  (accumulate op initial sequence))

;;;;;;;;;;;;;;;test
(fold-right / 1 (list 1 2 3))
(fold-left / 1 (list 1 2 3))
(fold-right list '() (list 1 2 3))
(fold-left list '() (list 1 2 3))
;;;;;;;;;;;用cons或list这些将产生不同结果
;;;;;;;;;;;要使用那些在操作数互换位置后意义相同的。

;;;;;;;;;;;;;;;;;;2.39

(define (reverse1 sequence)
  (fold-right (lambda (x y)
                (append y (list x))) '() sequence))

(define (reverse2 sequence)
  (fold-left (lambda (x y)
               (append (list y) x)) '() sequence))

;;;;;;;;;;;;test
(reverse1 (list 1 2 3 4 6 8 9))
(reverse2 (list 1 2 3 4 7 8 5))

终于会一点了

需要复习线性代数了，感觉白学了！