Exercise2.17～2.52

Exercise2.17

(define (last-pair xs)
  (if (null? (cdr xs))
      xs
      (last-pair (cdr xs))))

by iwk

Exercise2.18

(define (reverse xs)
  (if (null? xs)
      '()
      (append (reverse (cdr xs)) (list (car xs)))))

by iwk

Exercise2.19

(define us-coins (list 50 25 10 5 1))
(define uk-coins (list 100 50 20 10 5 2 1 0.5))
(define (cc amount coin-values)
  (cond ((= amount 0) 1)
	((or (< amount 0) (no-more? coin-values)) 0)
	(else
	 (+ (cc amount
		(except-first-denomination coin-values))
	    (cc (- amount
		   (first-denomination coin-values))
		coin-values)))))
(define (first-denomination coin-values)
  (car coin-values))
(define (except-first-denomination coin-values)
  (cdr coin-values))
(define (no-more? coin-values)
  (null? coin-values))

by iwk

Exercise2.20

(define (filter p xs)
  (cond ((null? xs) '())
	((p (car xs)) (cons (car xs) (filter p (cdr xs))))
	(else (filter p (cdr xs)))))
(define same-parity
  (lambda w
    (let ((parity (if (even? (car w))
	      even?
	      odd?)))
      (filter parity w))))

by iwk

Exercise2.21

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

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

by iwk

Exercise2.22

(define (square-list-it items)
  (define (square x) (* x x))
  (define (iter xs cont)
    (if (null? xs)
	(cont '())
	(iter (cdr xs) (lambda (c) (cont (cons (square (car xs)) c))))))
    (iter items (lambda (x) x)))

by iwk

Exercise2.23

(define (foreach proc xs)
  (if (null? (cdr xs))
      (proc (car xs))
      (let ((tmp (proc (car xs))))
	(foreach proc (cdr xs)))))

by iwk

Exercise2.24

Exercise2.25

(car (cdaddr '(1 3 (5 7) 9)))
=> 7
(caar '((7)))
=> 7
(cadadr (cadadr (cadadr '(1 (2 (3 (4 (5 (6 7)))))))))
=> 7

author iwk

Exercise2.26

(define x (list 1 2 3))
(define y (list 4 5 6))

(append x y)
=> (1 2 3 4 5 6)
(cons x y)
=> ((1 2 3) 4 5 6)
(list x y)
=> ((1 2 3) (4 5 6))

author iwk

Exercise2.27

(define (deep-reverse xxs)
  (if (null? xxs)
      '()
      (let ((x (car xxs))
           (xs (cdr xxs)))
       (append (deep-reverse xs) (list (if (pair? x) (reverse x) x))))))

author iwk

Exercise2.28

(define (fringe tree)
  (cond ((null? tree) '())
        ((not (pair? tree)) (list tree))
        (else (append (fringe (car tree)) (fringe (cdr tree))))))

author iwk

Exercise2.29

Exercise2.30

(define (square x) (* x x))
(define (square-tree-directly tree)
  (cond ((null? tree) '())
       ((pair? tree) (cons (square-tree-directly (car tree))
                           (square-tree-directly (cdr tree))))
       (else (square tree))))

(define (square-tree-map tree)
  (cond ((number? tree) (square tree))
       (else (map square-tree-map tree))))

author iwk

Exercise2.31

(define (tree-map proc tree)
  (cond ((list? tree) (map (lambda (subtree) (tree-map proc subtree)) tree))
       ((pair? tree) (cons (proc (car tree)) (proc (cdr tree))))
       (else (proc tree))))

author iwk

Exercise2.32

Exercise2.33

(define (map proc sequence)
  (accumulate (lambda (x y) (cons (proc x) y)) '() sequence))

(define (append fseq sseq)
  (accumulate cons sseq fseq))

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

author iwk

Exercise2.34

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

author iwk

Exercise2.34

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

author iwk

Exercise2.35

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

author iwk

Exercise2.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)))))

author iwk

Exercise2.37

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

(define (row-vector->list cont-vector)
  (car cont-vector))

(define (dot-product v w)
  (fold-right + 0 (map * v w)))

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

(define (matrix-*-matrix m n)
  (let ((transposed-n (transpose n)))
    (map (lambda (w) (matrix-*-vector m w)) n)))

author iwk

Exercise2.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))

author iwk

Exercise2.39

(define (reverse-r sequence)
  (use srfi-1)
  (fold-right (lambda (x y) (append y (list x))) '() sequence))
(define (reverse-l sequence)
  (use srfi-1)
  (fold-left (lambda (x y) (cons y x)) '() sequence))

author iwk

Exercise2.40

Exercise2.41

Exercise2.42

Exercise2.43

Exercise2.44

(define (up-split painter n)
  (if (= n 0)
      painter
      (let ((smaller (up-split painter (- n 1))))
       (below painter (beside smaller smaller)))))

author iwk

Exercise2.45

(define right-split (split beside below))
(define up-split (split below beside))
(define (split p q)
  (lambda (painter n)
    (if (= n 0)
       painter
       (let ((smaller ((split p q) painter (- n 1))))
         (p painter (q smaller smaller))))))

author iwk

Exercise2.46

(define (make-vect x y)
  (cons x y))
(define (xcor-vect v)
  (car v))
(define (ycor-vect v)
  (cdr v))
(define (add-vect v w)
  (make-vect (+ (xcor-vect v) (xcor-vect w))
           (+ (ycor-vect v) (ycor-vect w))))
(define (sub-vect v w)
  (make-vect (- (xcor-vect v) (xcor-vect w))
           (- (ycor-vect v) (ycor-vect w))))
(define (scale-vect s v)
  (make-vect (* s (xcor-vect v))
           (* s (ycor-vect v))))

author iwk

Exercise2.47

(define (make-frame-l origin edge1 edge2)
  (list origin edge1 edge2))
(define (origin-frame-l f)
  (list-ref f 0))
(define (xedge-frame-l f)
  (list-ref f 1))
(define (yedge-frame-l f)
  (list-ref f 2))

(define (make-frame-c origin edge1 edge2)
  (cons origin (cons edge1 edge2)))
(define (origin-frame-c f)
  (car f))
(define (xedge-frame-c f)
  (cadr f))
(define (yedge-frame-c f)
  (cddr f))

author iwk

Exercise2.48

(define (make-segment start-vect end-vect)
  (cons start-vect end-vect))
(define (start-vect seg)
  (car seg))
(define (end-vect seg)
  (cdr seg))

Exercise2.49

Exercise2.50

Exercise2.51

Exercise2.52