category

1 files changed, 188 insertions, 0 deletions

diff --git a/Computer_Science/SICP/ex2_17.scm b/Computer_Science/SICP/ex2_17.scm
new file mode 100644
index 0000000..37e3eb3
--- /dev/null
+++ b/Computer_Science/SICP/ex2_17.scm
@@ -0,0 +1,188 @@
+(cons 1
+      (cons 2
+            (cons 3
+                  (cons 4 nil))))
+
+(define one-through-four (list 1 2 3 4))
+
+one-through-four
+
+(car one-through-four)
+(cdr one-through-four)
+
+(define (list-ref items n)
+  (if (= n 0)
+    (car items)
+    (list-ref (cdr items)
+              (- n 1))))
+
+(list-ref one-through-four 3)
+
+(define (length items)
+  (if (null? items)
+    0
+    (+ 1 (length (cdr items)))))
+
+(define (length items)
+  (define (length-iter a count)
+    (if (null? a)
+      count
+      (length-iter (cdr a)
+                   (+ 1 count))))
+  (length-iter items 0))
+
+(define odds (list 1 3 5 7))
+(define squares (list 1 4 9 16 25))
+
+(define (append list1 list2)
+  (if (null? list1)
+    list2
+    (cons (car list1)
+          (append (cdr list1)
+                  list2))))
+
+(append odds squares)
+
+;; Exercise2.17
+(define (last-pair items)
+  (if (null? (cdr items))
+    (car items)
+    (last-pair (cdr items))))
+
+(last-pair (list 1 2 3 4 9 23))
+
+;; Exercise2.18
+(define (reverse items)
+  (if (null? (cdr items))
+    items
+    (append (reverse (cdr items))
+            (cons (car items) nil))))
+
+(list 4 3 2 1)
+(reverse (list 1 2 3 4))
+
+;; Exercise2.19 Counting change
+
+(define (count-change amount)
+  (cc amount 5))
+
+(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 (no-more? coin-values)
+  (null? coin-values))
+(define (except-first-denomination coin-values)
+  (if (null? coin-values)
+    null?
+    (cdr coin-values)))
+
+(cc 100 us-coins)
+
+;; Exercise2.20
+
+(define (same-parity x . y)
+  (define (find-same-parity parity z)
+    (if (null? z)
+      nil
+      (if (= parity 1)
+        (if (odd? (car z))
+          (cons (car z) (find-same-parity 1 (cdr z)))
+          (find-same-parity 1 (cdr z)))
+        (if (even? (car z))
+          (cons (car z) (find-same-parity 2 (cdr z)))
+          (find-same-parity 2 (cdr z))))))
+  (if (odd? x)
+    (cons x (find-same-parity 1 y))
+    (cons x (find-same-parity 2 y))))
+
+(define (same-parity first . rest)
+  (define (same-parity-iter source dist remainder-val)
+    (if (null? source)
+      dist
+      (same-parity-iter (cdr source)
+                        (if (= (remainder (car source) 2) remainder-val)
+                          (append dist (list (car source)))
+                          dist)
+                        remainder-val)))
+  (same-parity-iter rest (list first) (remainder first 2)))
+(same-parity 1 2 3 4 5 6 7)
+(same-parity 2 3 4 5 6 7)
+
+;; Exercise2.21
+(define (map proc items)
+  (if (null? items)
+    nil
+    (cons (proc (car items))
+          (map proc (cdr items)))))
+
+(define (squares items)
+  (map (lambda (x) (* x x)) items))
+(squares (list 1 2 3 4))
+
+;; Exercise2.22
+(define (square x) (* x x))
+(define (square-list items)
+  (define (iter things answer)
+    (if (null? things)
+      answer
+      (iter (cdr things)
+            (cons (square (car things))
+                  answer))))
+  (iter items nil))
+;; Modify one
+(define (square-list items)
+  (define (iter things answer)
+    (if (null? things)
+      answer
+      (iter (cdr things)
+            (cons answer
+                  (square 
+                    (car things))))))
+  (iter items nil))
+(square-list (list 1 2 3 4 5))
+(list 1 4 9 16 25)
+;; The right one;
+(cons 1 (cons 4 (cons 9 (cons 16 (cons 25 nil)))))
+;; The wrong one
+(cons (cons (cons (cons (cons nil 1) 4) 9) 16) 25)
+
+;; Exercise2.23
+;; why nil print '()
+(define (for-each proc items)
+  (define (iter proc items item)
+    (if (null? item)
+      nil
+      (proc item))
+    (if (null? items)
+      nil
+      (iter proc (cdr items) (car items))))
+  (iter proc items nil))
+
+(for-each
+  (lambda (x) (newline) (display x))
+  (list 57 321 88))
+
+(cons (list 1 2) (list 3 4))
+
+