sicp exercise ch2 - andstudy/forge GitHub Wiki

Soomong

Exercise 2.17. last-pair

    (define (last-pair list)
      (if (null? (cdr list))
          list
          (last-pair (cdr list))))
    
    (last-pair (list 23 72 149 34))

Exercise 2.18. reverse

    (define (reverse-new list)
      (if (null? (cdr list))
          list
          (cons (reverse-new (cdr list))
                (car list))))
    (reverse-new (list 1 4 9 16 25))

Exercise 2.20. same-parity

    (define (iter list fun)
      (if (null? list)
          '()
          (if (fun (car list))
              (cons (car list)
                    (iter (cdr list) fun))
              (iter (cdr list) fun))))
    (define (same-parity . x)
      (if (even? (car x))
          (iter x even?)
          (iter x odd?)))
    
    (same-parity 1 2 3 4 5 6 7)
    (same-parity 6 5 4 3 2 1)

Exercise 2.21. square-list

    (define (square-list items)
      (if (null? items)
          items
          (cons (* (car items) (car items))
                (square-list (cdr items)))))
    
    (define (square-map items)
      (map (lambda (x) (* x x)) items))
    
    (square-list (list 2 4 5))
    (square-map (list 2 4 5))

Exercise 2.27

    (define (reverse-new list)
      (if (null? (cdr list))
          list
          (cons (reverse-new (cdr list))
                (car list))))
    (reverse-new (list (list 1 2) (list 3 4)))

Exercise 2.30

    (define (square-tree tree)
      (cond ((null? tree) '())
            ((not (pair? tree)) (* tree tree))
            (else (cons (square-tree (car tree))
                        (square-tree (cdr tree))))))
    
    (define (square-tree-map tree)
      (map (lambda (x)
             (if (pair? x)
                 (square-tree-map x)
                 (* x x)))
           tree))
    
    (square-tree (list 1
                       (list 2 (list 3 4) 5)
                       (list 6 7)))
    (square-tree-map (list 1
                       (list 2 (list 3 4) 5)
                       (list 6 7)))

Exercise 2.31

    (define (tree-map fun tree)
      (map (lambda (x) 
             (if (pair? x)
                 (tree-map fun x)
                 (fun x)))
           tree))
    
    (define (square x) (* x x))
    (define (square-tree tree)
      (tree-map square tree))
    
    (square-tree (list 1
                       (list 2 (list 3 4) 5)
                       (list 6 7)))

Exercise 2.36

    (define (accumulate op initial sequence)
      (if (null? sequence)
          initial
          (op (car sequence)
              (accumulate op initial (cdr sequence)))))
    
    (define (accumulate-n op init seqs)
      (if (null? seqs) 
          '()
          (if (null? (car seqs))
              '()
              (cons (accumulate op init (map car seqs))
                    (accumulate-n op init (map cdr seqs))))))
    
    (define s (list (list 1 2 3) (list 4 5 6) (list 7 8 9) (list 10 11 12)))
    (accumulate-n + 0 s)

김명관

Exercise 2.18. reverse

    (define (reverse-new param)
      (define (reverse-iter n o)
        (if (null? o)
            n
            (reverse-iter (cons (car o) n) (cdr o))))
      (reverse-iter (list) param))
    
    (reverse-new (list 1 4 9 16 25))

Exercise 2.20. same-parity

    (define (same-parity x . z)
      (define (iter n o)
        (if (null? o)
            (reverse n)
            (if (equal? (even? x)
                        (even? (car o)))
                (iter (cons (car o) n) (cdr o))
                (iter n (cdr o)))))
      (iter (list x) z))
    
    (same-parity 1 2 3 4 5 6 7)
    (same-parity 2 3 4 5 6 7)

Exercise 2.23. for-each

    (define (for-each2 proc items)
      (if (null? items)
          (newline)
          (and (proc (car items)) (for-each2 proc (cdr items))) ))
    
    (for-each2 (lambda (x) (newline) (display x))
               (list 57 321 88))

Exercise 2.25

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

Exercise 2.27

    (define (deep-reverse items)
      (define (iter n o)
        (cond ((null? o) n)
              (else (iter (cons (if (pair? (car o))
                                    (iter (list) (car o))
                                    (car o))
                                n)
                          (cdr o)))))
      (iter (list) items))
    
    (define x (list (list 1 2) (list 3 4)))
    (deep-reverse x)

Exercise 2.28

    (define (fringe x)
      (cond ((null? x) (list))
            ((not (pair? x)) (list x))
            (else (append (fringe (car x))
                          (fringe (cdr x))))))
    
    (define x (list (list 1 2 ) (list 3 4 )))
    (fringe x)
    (fringe (list x x))

Exercise 2.30

    (define (square-tree x)
      (cond ((null? x) (list))
            ((not (pair? x)) (* x x))
            (else (cons (square-tree (car x))
                        (square-tree (cdr x))))))
    
    (define (square-tree2 x)
      (map (lambda (sub-tree)
             (if (pair? sub-tree)
                 (square-tree2 sub-tree)
                 (* sub-tree sub-tree)))
           x))
    
    (define x
     (list 1
           (list 2 (list 3 4) 5)
           (list 6 7)))
    (square-tree x)
    (square-tree2 x)

bt22d

• MIT Scheme으로 코드를 작성하였기 때문에
• Dr. Scheme에서 테스트 하시려면 기본 프로시저의 이름을 바꾸셔야 합니다.
• (ex. append -> append1/append-new)

Exercise 2.17

    (define (last-pair items)
      (if (null? (cdr items))
          items
          (last-pair (cdr items))))
    (last-pair (list 23 34 39 99))

Exercise 2.18. reverse

    (define (reverse items)
      (if (null? (cdr items))
          items
          (append (reverse (cdr items)) (list (car items)))))
    (reverse (list 1 2 3 4))
    ; output : (4 3 2 1)

Exercise 2.20

    (define (parity-list items fun)
      (if (null? items)
          items
          (if (fun (car items))
    	  (cons (car items) (parity-list (cdr items) fun))
    	  (parity-list (cdr items) fun))))
    
    (define (same-parity p . items)
      (cons p (parity-list items 
                           (if (odd? p) odd? even?))))
    (same-parity 2 3 4 5 6)

Exercise 2.23. for-each

    (for-each (lambda (x) (newline) (display x))
    	  (list 1 2 34 5))
    (define (for-each1 proc items)
      (if (null? items)
          (proc items)
          (for-each1 proc (cdr items))))

Exercise 2.27

    (define x (list (list 1 2) (list 3 4)))
    
    (define (deep-reverse items)
      (cond ((not (pair? items)) items)
    	(else (append (deep-reverse (cdr items)) 
                      (list (deep-reverse (car items)))))))
    (deep-reverse x)
    ; output : ((4 3) (2 1))

Exercise 2.28

    (define (fringle tree)
      (cond ((null? tree) '())
    	((not (pair? tree)) (list tree))
    	(else (append (fringle (car tree))
    		      (fringle (cdr tree))))))
    (fringle (list 1 (list 2 (list 3 4)) 5))

Exercise 2.30

    (square-tree
     (list 1
           (list 2 (list 3 4) 5)
           (list 6 7)))
    
    (define (square-tree tree)
      (cond ((null? tree) '())
    	((not (pair? tree)) (square tree))
    	(else (cons (square-tree (car tree))
    				 (square-tree (cdr tree))))))
    
    (define (square-tree tree)
      (map (lambda (sub-tree)
    	 (if (pair? sub-tree)
    	     (square-tree sub-tree)
    	     (square sub-tree)))
           tree))

Exercise 2.31

    (define (tree-map proc tree)
      (cond ((null? tree) '())
    	((not (pair? tree)) (proc tree))
    	(else (cons (tree-map proc (car tree))
    		    (tree-map proc (cdr tree))))))
    (define (square-tree tree) (tree-map square tree))
    (square-tree
     (list 1 (list 2 (list 3 4) 5) (list 6 7)))

Exercise 2.32

    (define (subsets s)
      (if (null? s)
          (list '())
          (let ((rest (subsets (cdr s))))
    	(append rest (map (lambda (x)
    			    (cons (car s) x)) rest)))))
    (subsets (list 1 2 3))
    ; output : (() (3) (2) (2 3) (1) (1 3) (1 2) (1 2 3))

Exercise 2.33

    (define (map p sequence)
      (accumulate (lambda (x y) (cons (p x) y)) '() sequence))
    (map square (list 1 2 3 4))
    
    (define (append seq1 seq2)
      (accumulate cons seq2 seq1))
    (append (list 1 2 3) (list 4 5 6))
    
    (define (length sequence)
      (accumulate (lambda (x y) (+ 1 y)) 0 sequence))

Exercise 2.35

    (define (count-leaves t)
      (accumulate + 0 (map (lambda x 1) (enumerate-tree t))))
    (count-leaves (list 1 (list 2 (list 3 4)) 5))
    ; output : 5

Exercise 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)))))
    (accumulate-n + 0 (list (list 1 2 3) (list 4 5 6) (list 7 8 9) (list 10 11 12)))
    ; output : (22 26 30)

Exercise 2.37

    (define (dot-product v w)
      (accumulate + 0 (map * v w)))
    
    (define (matrix-*-vector m v)
      (map (lambda x (dot-product v (car x))) m))
    
    (define (transpose mat)
      (accumulate-n cons '() mat))
    
    (define (matrix-*-matrix m n)
      (let ((cols (transpose n)))
        (map (lambda x (accumulate-n * 1 cols)) m)))

Exercise 2.39

    (define (reverse sequence)
      (fold-right (lambda (x y) (append y (list x))) '() sequence))
    
    ; fold-left 버전 한참 고민했었는데... -_-;; 정오표 참고하세요.
    (define (reverse sequence)
      (fold-left (lambda (x y) (cons y x)) '() sequence))

kukuman

Exercise 2.17. last-pair

    (define (last-pair1 list1)
     (if( null? (cdr list1))
        list1
        (last-pair1 (cdr list1))
     ))
    (last-pair1 (list 23 72 149 34))

Exercise 2.27

    ( define (reverse1 list1)
       (null? cdr list1)
       (list1)
       (cons ( reverse1(cdr list1) car list1))
    )
    
    (reverse (list 1 4 9 16 25)) 

ogmj

문제 2.53

    (list 'a 'b 'c)
    >> (a b c)
    (list (list 'george))
    >> ((george))
    (cdr '((x1 x2) (y1 y2)))
    >> ((y1 y2))
    (cadr '((x1 x2) (y1 y2)))
    >> (y1 y2)
    (pair? (car '(a short list)))
    >> #f
    (memq 'red '((red shoes) (blue shoes)))
    >> #f
    (memq 'red '((red shoes)))
    >> #f
    
    번외
    (memq 'red '(red shoes))
    >> (red shoes)
    (memq 'red '(red shoes blue socks))
    >> (red shoes blue socks)
    (memq 'red '(blue shoes blue socks))
    >> #f

문제 2.54

    문제 2.54 eq?를 사용한 되돌리기 프로시저로 equal?를 구현하라.
    (define (equal-n a b)
      (cond ((null? a) false)
            ((null? b) false)
            (else (cond ((eq? (car b) (car a)) 
                         (if (and (null? (cdr a)) (null? (cdr b)))
                          true
                          (equal-n (cdr a) (cdr b)))
                         )
                   (else false))
                  )
            )
      )
    
    결과
    (equal-n '() '())
    >> #f
    (equal-n '(a) '())
    >> #f
    (equal-n '() '(a))
    >> #f
    (equal-n '(a c b) '(a b c))
    >> #f
    (equal-n '(this is a list) '(this (is a) list))
    >> #f
    (equal-n '(this is a list) '(this is a list))
    >> #t
    (equal-n (list 1 2 3 4) (list 1 2 3 4))  
    >> #t
    (equal-n (list 1 2 3 4) (list 1 2 3)) 
    >> #f

문제 2.55

    (car ''abracadabra)
    >> quote
    (car '(abracadabra))
    >> abracadabra
    (car '(a))
    >> a
    (car '(a b c))
    >> a
    (car (quote (a b c)))
    >> a
    ;(car (quote a b c))
    >> bad syntax
    (car (quote (quote (abracadabra))))
    >> quote

문제 2.56

    (define (deriv exp var)
      (cond ((number? exp) 0)
            ((variable? exp)
             (if (same-variable? exp var) 
                 1 
                 0))
            ((sum? exp)
              (make-sum (deriv (addend exp) var)
                        (deriv (augend exp) var)))
            ((product? exp)
             (make-sum 
              (make-product (multiplier exp)
                            (deriv (multiplicand exp) var))
              (make-product (deriv (multiplier exp) var)
                            (multiplicand exp))))
            ((exponentiation? exp)
             (make-product
              (exponect exp)
              (make-product
               (make-exponentiation (base exp) 
                                   (exponect exp))
               (deriv (base exp) var))))
               
             (else
              (error "unknown expression type -- DERIV" exp))))
    
    ;지수연산
    (define (exponentiation? x)
      (and (pair? x) (eq? (car x) '**)))
    ;밑수연산
    (define (base x)(cadr x))
    ;(define (base x var)
    ;  (if (eq? (cadr x) var)
    ;      (cadr x) 
    ;       0))
    
    ;윗수연산
    (define (exponect x) (caddr x))
    
    (define (make-exponentiation b e)
      (cond ((=number? b 0) 0)
            ((=number? e 0) (list '1))
            ((=number? e 1) (list b))
            (else (list '** b (- e 1)))))
      
    ;1미분식의 변수는 글자로 나타낸다. 
    ;어떤 값이 기호인지 아닌지 알아보는 기본 프로시저는 symbol?이다.
    (define (variable? x) (symbol? x))
    
    ;2변수를 나타내는 두 기회가 eq?하다면, 두 변수는 같다.
    (define (same-variable? v1 v2) 
      (and (variable? v1) (variable? v2) (eq? v1 v2)))
    
    ;3덧셈 식과 곱셈 식은 리스트를 써서 짜맞춘다.
    (define (make-sum a1 a2) 
      ;(list '+ a1 a2))
      (cond ((=number? a1 0)
             a2)
            ((=number? a2 0)
             a1)
            ((and (number? a1 ) (number? a2))
             (+ a1 a2))
            (else (list '+ a1 a2))))
    ;3-1
    (define (=number? exp num)
      (and (number? exp) (= exp num)))
    
    (define (make-product m1 m2) 
      ;(list '* m1 m2))
      (cond ((or (=number? m1 0) (=number? m2 0)) 0)
            ((=number? m1 1) m2)
            ((=number? m2 1) m1)
            ((and (number? m1) (number? m2)) (* m1 m2))
            (else (list '* m1 m2))))
    
    ;4덧셈 식은 첫 번째 원소가 +기호로 시작되는 리스트이다.
    (define (sum? x)
      (and (pair? x) (eq? (car x) '+)))
    
    ;5더하임 수는 리스트의 2번째 원소이다.
    (define (augend s) (cadr s))
    
    ;6덧수는 덧셈 리스트이 3번째 원소이다.
    (define (addend s) (caddr s))
    
    ;7곱셈 식은 첫 번째 원소가 *기호로 시작되는 리스트이다.
    (define (product? x)
      (and (pair? x) (eq? (car x) '*)))
    
    ;8곱하임수는 곱셈 리스트의 2번째 원소이다.
    (define (multiplicand p) (cadr p))
    
    ;9곱수는 곱셈 리스트의 3번째 원소이다.
    (define (multiplier p) (caddr p))
    
    ;결과
    (deriv '(+ x 3) 'x)
    >> 1
    (deriv '(* x y) 'x)
    >> y
    (deriv '(* (* x y) (+ x 3)) 'x)
    >> (+ (* (+ x 3) y) (* x y))
    (deriv '(* x x) 'x)
    >> (+ x x)
    (deriv '(** x 3) 'x)
    >> (* 3 (** x 2))
    (deriv '(** x 2) 'x)
    >> (* 2 (** x 1))
    (deriv '(** x 1) 'x)
    >> (x)
    (deriv '(** x 0) 'x)
    >> 0
    (deriv '(+ (** x 4) (** x 3) (** x 2)) 'x)
    >> (+ (* 3 (** x 2)) (* 4 (** x 3))) ;2마디까지만 계산됨
    (deriv '(+ (** x 4) (** x 3)) 'x)
    >> (+ (* 3 (** x 2)) (* 4 (** x 3)))
    (deriv '(** z 4) 'x)
    >> 0

문제 2.57

    NoSyu님 답
    ;5더하임 수
    (define (augend s) 
     ; (cadr s))
      (if (null? (cdddr s))
          (caddr s)
          (make-sum (caddr s) (cadddr s))))
    
    ;8곱하임 수
    (define (multiplicand p) 
     ; (cadr p))
      (if (null? (cdddr p))
          (caddr p)
          (make-product (caddr p) (cadddr p))))
    
    (deriv '(+ (** x 4) (** x 3) (** x 2)) 'x)
    >> (+ (* 3 (** x 2)) (+ (* 2 (** x 1)) (* 2 (** x 1)))) ; 답이 이상함
    
    ogmj 검산
    ;6덧수
    (define (addend s) 
     ; (caddr s))
      (if (null? (cdddr s))
          (caddr s)
          (make-sum (caddr s) (cadddr s))))
    
    ;9곱수
    (define (multiplier p) 
     ; (caddr p))
      (if (null? (cdddr p))
          (caddr p)
          (make-product (caddr p) (cadddr p))))
    
    (deriv '(+ (* 3 (** x 3)) (* x 2)) 'x)
    >> (+ 2 (* (* 3 (** x 2)) 3)) ;9x^2 + 2
    (deriv '(+ (** x 4) (** x 3) (** x 2)) 'x)
    >> (+ (+ (* 2 (** x 1)) (* 3 (** x 2))) (* 4 (** x 3))) ;4x^3 + 3x^2 + 2x

문제 2.59

    ;Language - Pretty Big
    (define (element-of-set? x set)
      (cond ((null? set) false)
            ((equal? x (car set)) true)
            (else (element-of-set? x (cdr set)))))
    
    (define (adjoin-set x set)
      (if (element-of-set? x set)
          set
          (cons x set)))
    
    (define (intersection-set set1 set2)
      (cond ((or (null? set1) (null? set2)) '()) 
            ((element-of-set? (car set1) set2)
             (cons (car set1)
                   (intersection-set (cdr set1) set2)))
           (else (intersection-set (cdr set1) set2))))
    
    
    (define (unio-set set1 set2)
      ;두 집합이 둘다 비었으면 공집합 표시
      (cond ((null? set1) set2)
            ((null? set2) set1)
             ;set1의 1번 원소랑 set2의 원소들과 비교
             ((element-of-set? (car set1) set2)
              ;같은 원소가 있으면 set1의 다음원소를 검사
              (unio-set (cdr set1) set2))
             ;같은 원소가 없으면 set2에 추가
            (else (cons (car set1)
                  (unio-set (cdr set1) set2)))))
     ;       (else
     ;        (unio-set (adjoin-set (car set2) set1) (cdr set2)))))
                  
    
    (define x1 (list 1 2 3 5))
    (define y1 (list 2 3 4))
    x1
    >> (1 2 3 5)
    y1
    >> (2 3 4)
    (element-of-set? 5 x1)
    >> #t
    (intersection-set x1 y1)
    >> (2 3)
    (unio-set x1 y1)
    >> (1 5 2 3 4)
    x1
    >> (1 2 3 5)
    y1
    >> (2 3 4)

문제 2.61

    (define (element-of-set? x set)
      (cond ((null? set) false)
            ((= x (car set)) true)
            ((< x (car set)) false)
            (else (element-of-set? x (cdr set)))))
    
    (define (intersection-set set1 set2)
      (if (or (null? set1) (null? set2))
          '()
          (let ((x1 (car set1)) (x2 (car set2)))
            (cond ((= x1 x2)
                   (cons x1
                         (intersection-set (cdr set1)
                                           (cdr set2))))
                  ((< x1 x2)
                   (intersection-set (cdr set1) set2))
                  ((< x2 x1)
                   (intersection-set set1 (cdr set2))))))) 
    
    (define (adjoin-set x set)
      (cond ((equal? x (car set)) set)
            ((< (car set) x)
             (if (null? (cdr set))
                 (list (car set) x)
                 (cons (car set) (adjoin-set x (cdr set)))))
            ((< x (car set)) (cons x set)))) 
    
    (define x1 (list 2 4 6))
    x1
    >> (2 4 6)
    (adjoin-set 1 x1)
    >> (1 2 4 6)
    (adjoin-set 2 x1)
    >> (2 4 6)
    (adjoin-set 7 x1)
    >> (2 4 6 7)

jaejyn

Exercise 2.2.

    (define (x-point p) (car p))
    
    (define (y-point p) (cdr p))
    
    (define (make-point x y)
      (cons x y))
    
    (define (start-seg seg) (car seg))
    
    (define (end-seg seg) (cdr seg))
    
    (define (make-seg s e)
      (cons s e))
    
    (define (mid-value x y)
      (/ (+ x y) 2))
    
    (define (midpoint-seg s e)
      (make-seg (mid-value (x-point s) (x-point e)) 
                (mid-value (y-point s) (y-point e)))) 

Exercise 2.3.

    (define (make-rect topLeft bottomRight)
      (cons topLeft bottomRight))
    
    (define (topLeft-rect rect)
      (car rect))
    
    (define (bottomRight-rect rect)
      (cdr rect))
    
    (define (width-rect rect)
      (- (x-point (bottomRight-rect rect)) (x-point (topLeft-rect rect))))
    
    (define (height-rect rect)
      (- (y-point (topLeft-rect rect)) (y-point (bottomRight-rect rect))))
    
    (define (round-rect rect)
      (* 2 (+ (width-rect rect) (height-rect rect))))
    
    (define (area-rect rect)
      (* (width-rect rect) (height-rect rect)))

Exercise 2.7.

    (define (upper-bound interval)
      (cdr interval))
    
    (define (lower-bound interval)
      (car interval))

Exercise 2.8.

    (define (sub-interval x y)
      (add-interval x (mul-interval -1 y)))

Exercise 2.11.

    (define (new-mul-interval x y)
      (cond ((and (minus-plus x) (plus-plus y)) (make-interval (* (lower-bound x) (upper-bound y)) (* (upper-bound x) (upper-bound y))))
            ((and (plus-plus x) (minus-plus y)) (make-interval (* (upper-bound x) (lower-bound y)) (* (upper-bound x) (upper-bound y))))
            ((and (minus-minus x) (plus-plus y)) (make-interval (* (lower-bound x) (upper-bound y)) (* (upper-bound x) (lower-bound y))))
            ((and (plus-plus x) (minus-minus y)) (make-interval (* (upper-bound x) (lower-bound y)) (* (lower-bound x) (upper-bound y))))
            
            ((and (minus-plus x) (minus-plus y)) (make-interval (min (* (lower-bound x) (upper-bound y)) (* (upper-bound x) (lower-bound x)))
                                                                (max (* (lower-bound x) (lower-bound y)) (* (upper-bound x) (upper-bound y)))))
            
            ((and (minus-minus x) (minus-plus y)) (make-interval (* (lower-bound x) (upper-bound y)) (* (lower-bound x) (lower-bound y))))
            ((and (minus-plus x) (minus-minus y)) (make-interval (* (upper-bound x) (lower-bound y)) (* (lower-bound x) (lower-bound y))))
            ((and (minus-minus x) (minus-minus y)) (make-interval (* (upper-bound x) (upper-bound y)) (* (lower-bound x) (lower-bound y))))
            ((and (plus-plus x) (plus-plus y)) (make-interval (* (lower-bound x) (lower-bound y)) (* (upper-bound x) (upper-bound y))))))

Exercise 2.54.

    (define (equal? x y)
      (define (equal_iter a b)
        (cond ((and (null? a) (null? b))
            'true)
            ((not (equal_length? a b))
             'false)
            ((eq? (car a) (car b)) 
             (equal_iter (cdr a) (cdr b)))
            (else 'false)))
      (equal_iter x y))

Exercise 2.56.

    (define (exponentiation? x)
      (and (pair? x) (eq? (car x) '**)))
    (define (base p) (cadr p))
    (define (exponent p) (caddr p))
    (define (make-exponentiation m1 m2) 
      (cond 
           ((=number? m1 0) 0)
           ((=number? m2 0) 1)
           ((and (number? m1) (number? m2)) (fast-expt m1 m2))
           (else (list '** m1 m2))))
    
    (define (deriv exp var)
      (cond ((number? exp) 0)
                ((variable? exp)
                  (if (same-variable? exp var) 1 0))
                ((sum? exp)
                  (make-sum (deriv (addend exp) var)
                     (deriv (augend exp) var)))
               ((product? exp)
                 (make-sum
                  (make-product (multiplier exp)
                      (deriv (multiplicand exp) var))
                  (make-product (deriv (multiplier exp) var)
                           (multiplicand exp))))
               ((exponentiation? exp)
                 (make-product (exponent exp)
                              (make-product  (make-exponentiation (base exp) (- (exponent exp) 1)) 
                                                       (deriv (base exp) var))))
              (else
                (error "unknown expression type -- DERIV" exp))))

Exercise 2.59.

    (define (union-set set1 set2)
      (cond     
        ((null? set1) set2)
        ((null? set2) set1)
        (else (union-set (adjoin-set (car set2) set1) (cdr set2)))))

Exercise 2.61.

    (define (adjoin-set x set)
      (cond ((null? set) '()) 
                ((> x (car set)) (cons (car set) (adjoin-set x (cdr set))))
                ((< x (car set)) (cons x set))
                ((= x (car set)) set)))

Exercise 2.62.

    (define (union-set set1 set2)
      (cond ((null? set1) set2)
    		((null? set2) set1)
    		(else (let ((x1 (car set1)) (x2 (car set2)))
    					(cond ((< x1 x2) (cons x1 (union-set (cdr set1) set2)))
    				   ((> x1 x2) (cons x2 (union-set set1 (cdr set2))))
    				   ((= x1 x2) (cons x1 (union-set (cdr set1) (cdr set2)))))))))

seedyoon

문제 2.74

    a
    ;get-record 프로시저
    ;인사파일에서 지정된 직원 레코드를 뽑애낼 수있음
    ;저마다 구조가 다른 프로시저에 적용되어야 
    
    (define (get-record file employee_name)
     ((get 'get-record )) file employee_name)
    
    b
    ; 부서 인사 파일에서 봉급정보를 찾아볼수 있는 get-selary 프로시저
    ; 부서 인사 파일
    (define (get-salary file )
      ((get 'get-salary file ))
      
    c  
    ; 모든 부서의 파일을 뒤지고
    ; 어떤 직원의 기록을 찾을 수 있도록 프로시저 구현
    ; 직원이름, 모든 부서 파일의 리스트가 인자.
    (define (find-employee-record file-list employee-name)
      (if (null? file-list)
          (error 'NotFound employee)
          (or (get-record (car file-list) employee-name)
              (find-employee-record (cdr file-list) employee-name))))
    
    d
    ; 합병시 바뀔 점
    ; 새로운 부서리스트 파일(합병 회사)을 추가
    ; 새로 추가된 부서별 프로시저를 정의 해야 put 해준다.
    ; 나머지는 다른점이 없음 

문제 2.75

    (define (make-from-mag-ang r a)
      (define (dispatch op)
        (cond ((eq? op 'real-part) (* r (cos a)))
              ((eq? op 'imag-part) (* r (sin a)))
              ((eq? op 'magnitude) r)
              ((eq? op 'angle) a)
              (else
               (error "Unknown op -- MAKE-FROM-MAG-ANG" op))))
      dispatch)

문제 2.76

    ; 주관적인 의견으로 틀릴수 있습니다 ㅡ_ㅜ
    직접 나눠 맡기는 방식 
     - 확실한 역활의 분리는 되지만 각 연산과 프로시저의 이름과 정의를 모두 해 주어야 함
     - 사용하고자 하는 타입과 연산을 전체 시스템에서 알아야 함
     - c global
     
     
    데이터 중심 방식
     - 타입에 따라 인터페이스를 정의, 해당 데이터 내의 프로시저및 연산을 사용
     - 해당 꾸러미 내에서 어떤 연산을 처리할지 타입 정의에 의해 실행.
     - 추가되는 데이터 타입에 따라 연산 및 프로시저를 정의해 주어야 함
     - c++ Class  
    
    메시지 패싱 방식
     - Dispathch 연산을 통해서 각각에 맞는 프로시저 및 연산을 실행
     - 메시지 타입에 의해 인터페이스에 정의된 연산 및 프로시저를 실행
     - 실행되는 부분에 어떤 데이터가 있는지 알 필요 없음?
     - 일반화된 프로시저에서 인자를 오로지 하나밖에 받지 못한다.
     - socket 통신 및 window msg
    
    
    
    새로운 데이터 타입을 집어넣어야 할 일이 많다면? 어느방식?
    	한가지 데이터 내부에서 해당 데이터에 관련된 처리가 모두 이루어져야 된다.
    	즉, 데이터 타입에 따라 해야 할 일들이 분리되어야 함(세로 요약의 경계(p223)) 
    	데이터 중심 방식을 사용하는 것이 나음
    
    
    새로운 연산을 덧붙이는 경우가 많을때는?
    	동일한 인터페이스로 정의하여서 넘어온 프로시저만을 확인하여서 사용. 
    	다른 데이터와의 상관 없이 추가, 변경이 용이한 메시지 패싱 방식으로 하는것이 낫다.

Mastojun

연습문제 2.1

    (define (gcd a b)
      (if (= b 0)
          a
          (gcd (abs b) (remainder (abs a) (abs b)))))
    
    (define (make-rat n d)
      (let ((g (gcd n d))
            (a (abs n))
            (b (abs d)))
        (if (< (* n d) 0 )
            (cons (- (/ a g)) (/ b g))
            (cons (/ a g) (/ b g)))))
    
    (define (numer x) (car x))
    (define (denom x) (cdr x))
    
    (define (add-rat x y)
      (make-rat (+ (* (numer x) (denom y))
                   (* (numer y) (denom x)))
                (* (denom x) (denom y))))
    
    (define (sub-rat x y)
      (make-rat (- (* (numer x) (denom y))
                   (* (numer y) (denom x)))
                (* (denom x) (denom y))))
    
    (define (mul-rat x y)
      (make-rat (* (numer x) (numer y))
                (* (denom x) (denom y))))
    
    (define (div-rat x y)
      (make-rat (* (numer x) (denom y))
                (* (denom x) (numer y))))
    
    (define (equal-rat? x y)
      (= (* (numer x) (denom y))
         (* (numer y) (denom x))))
    
    (define (print-rat x)
      (newline)
      (display (numer x))
      (display "/")
      (display (denom x)))
    
    (define one-half (make-rat -1 2))
    (print-rat one-half)
    (define one-third (make-rat 1 3))
    (print-rat (add-rat one-half one-third))
    (print-rat (mul-rat one-half one-third))
    (print-rat (add-rat one-third one-third))

연습문제 2.2

    (define (make-segment s e) (cons s e))
    (define (start-segment x) (car x))
    (define (end-segment x) (cdr x))
    
    (define (make-point s e) (cons s e))
    (define (x-point x) (car x))
    (define (y-point y) (cdr y))
    
    (define (midpoint-segment x)
      (make-point (/ (+ (x-point (start-segment x)) (x-point (end-segment x))) 2)
                  (/ (+ (y-point (start-segment x)) (y-point (end-segment x))) 2)))
    
    (define (print-point p)
      (newline)
      (display "(");
      (display (x-point p))
      (display ",")
      (display (y-point p))
      (display ")"))
    
    (define testLint (make-segment (make-point 1 1) (make-point 2 2)))
    
    (print-point (midpoint-segment testLint))

2.4 연습문제

    (define (cons x y)
      (lambda (m) (m x y)))
    
    (define (car z)
      (z (lambda (p q) p)))
    
    (define (cdr z)
      (z (lambda (p q) q)))
    
    (define x (cons 1 2))
    (car x)
    (cdr x)

연습문제 2.7, 2.8

    (define (add-interval x y)
      (make-interval (+ (lower-bound x) (lower-bound y))
                     (+ (upper-bound x) (upper-bound y))))
    
    (define (mul-interval x y)
      (let ((p1 (* (lower-bound x) (lower-bound y)))
            (p2 (* (lower-bound x) (upper-bound y)))
            (p3 (* (upper-bound x) (lower-bound y)))
            (p4 (* (upper-bound x) (upper-bound y))))
        (make-interval (min p1 p2 p3 p4)
                       (max p1 p2 p3 p4))))
    
    (define (div-interval x y)
      (mul-interval x
                    (make-interval (/ 1.0 (upper-bound y))
                                   (/ 1.0 (lower-bound y)))))
    
    (define (make-interval a b) (cons a b))
    
    (define (upper-bound x)
      (if (> (car x) (cdr x))
          (car x)
          (cdr x)))
    
    (define (lower-bound x)
      (if (> (car x) (cdr x))
          (cdr x)
          (car x)))
    
    (define (sub-interval x y)
      (make-interval (- (lower-bound x) (lower-bound y))
                     (- (upper-bound x) (upper-bound y))))

연습문제 2.9

    ; 이렇게 하는게 맞는지 @_@
    ; (((upper-bound x) ± (upper-bound y)) - ((lower-bound x) ± (lower-bound y)))/2
    ; (((upper-bound x) +- (upper-bound y)) - (lower-bound x) -+ (lower-bound y))/2
    ; ((upper-bound x) - (lower-bound x) +- (upper-bound y) -+ (lower-bound y))/2
    ; ((upper-bound x) - (lower-bound x))/2 + ( +- (upper-bound y) -+ (lower-bound y))/2
    ; + : width of x + width of y
    ; - : width of x - width of y
    ; 
    ; 곱하기나 나누기는 더하고 있는(또는 빼고 있는) 구간 값의 폭으로 일반화 시킬 수 없음.
    ; 해보진 않았지만 아마도?

연습문제 2.17, 2.18

    (define (length items)
      (define (length-iter a count)
        (if (null? a)
            count
            (length-iter (cdr a) (+ 1 count))))
      (length-iter items 0))
    
    ; 2.17
    (define (last-pair items)
      (if (= 1 (length items))
          items
          (last-pair (cdr items))))
    
    (define (delete-end items)
        (if (= 1 (length items))
            null
            (cons (car items) (delete-end (cdr items)))))
    ; 2.18
    (define (reverse items)
      (if (= 1 (length items))
          items
          (cons (car (last-pair items)) (reverse (delete-end items)))))

연습문제 2.20

    (define (same-parity n . items)
      (define (find-even items)
        (if (null? items)
            null
            (if (even? (car items))
                (cons (car items) (find-even (cdr items)))
                (find-even (cdr items)))))
      (define (find-odd items)
        (if (null? items)
            null
            (if (even? (car items))
                (find-odd (cdr items))
                (cons (car items) (find-odd (cdr items))))))
      
      (if (even? n)
          (cons n (find-even items))
          (cons n (find-odd items))))
      
    
    (same-parity 1 2 3 4 5 6 7)
    (same-parity 2 3 4 5 6 7)

연습문제 2.21

    (define (square-list items)
      (if (null? items)
          null
          (cons (* (car items) (car items)) (square-list (cdr items)))))
    ;문제의 의도를 무시하고 Scheme 기본 연산자를 사용 =_=;;
    (define (square-list-2 items)
      (map * items items))
    
    
    (square-list (list 1 2 3 4))
    (square-list-2 (list 1 2 3 4))

연습문제 2.23

    ; 좀 억지스러운 =_=;
    (define (for-each-mine fun items)
      (if (null? items)
          (newline)
          (and (fun (car items)) (for-each-mine fun (cdr items)))))
    
    (for-each (lambda (x) (newline) (display x))
              (list 57 321 99))
    
    (for-each-mine (lambda (x) (newline) (display x))
                   (list 57 321 99))

연습문제 2.25

    ;(1 3 (5 7) 9)
    (define list1 (list 1 3 (list 5 7) 9))
    list1
    (car (cdr (car(cdr (cdr list1)))))
    (newline)
    ;((7))
    (define list2 (list (list 7)))
    list2
    (car (car list2))
    (newline)
    ;(1 (2 (3 (4 (5 (6 7))))))
    (define list3 (list 1 (list 2 (list 3 (list 4 (list 5 (list 6 7)))))))
    list3
    (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr list3))))))))))))
    
    (newline)

연습문제 2.28

    (define (fringe items)
      (if (pair? items)
          (append (fringe (car items)) (fringe (cdr items)))
          (if (null? items)
              null
              (list items))))
    
    (define 2.28.x (list (list 1 2) (list 3 4)))
    
    2.28.x
    
    (fringe 2.28.x)
    (fringe (list 2.28.x 2.28.x))