10 exercises not bad

12 files changed, 173 insertions, 11 deletions

diff --git a/coding-exercises/2/18.rkt b/coding-exercises/2/18.rkt
index 5fab5f8..56f7987 100644
--- a/coding-exercises/2/18.rkt
+++ b/coding-exercises/2/18.rkt
@@ -3,13 +3,13 @@
 
 ;; grow in reverse method
 ;; or pointer reversal method in other languages
-(define (reverse-rec l) 
+(define (reverse l)
   (define (iter l p)
-   (cond 
+   (cond
      ((null? l) p)
      (else
-      (iter 
-        (cdr l) 
+      (iter
+        (cdr l)
         (cons (car l) p)))))
   (iter l (list)))
 
diff --git a/coding-exercises/2/19.rkt b/coding-exercises/2/19.rkt
new file mode 100644
index 0000000..d0ade7f
--- /dev/null
+++ b/coding-exercises/2/19.rkt
@@ -0,0 +1,17 @@
+#lang racket
+(require sicp)
+
+(define (cc-list amount kinds-of-coins)
+  (cond ((= amount 0) 1)
+        ((or (< amount 0) (empty? kinds-of-coins)) 0)
+        (else (+ (cc-list amount 
+                          (cdr kinds-of-coins))
+                 (cc-list (- amount 
+                             (car kinds-of-coins)) 
+                          kinds-of-coins)))))
+
+(define us-coins (list 50 25 10 5 1))
+(cc-list 100 us-coins)
+
+(define uk-coins (list 100 50 20 10 5 2 1 0.5))
+(cc-list 100 uk-coins)
diff --git a/coding-exercises/2/20.rkt b/coding-exercises/2/20.rkt
new file mode 100644
index 0000000..e2a1696
--- /dev/null
+++ b/coding-exercises/2/20.rkt
@@ -0,0 +1,15 @@
+#lang racket
+(require sicp)
+
+(define (f x y . z) (+ x y (car z)))
+
+(define (same-parity n . o)
+  (define p (remainder n 2))
+  (define (rec others)
+    (cond ((null? others) others)
+          ((= (remainder (car others) 2) p) (cons (car others) (rec (cdr others))))
+          (else  (rec (cdr others)))))
+  (cons n (rec o)))
+
+(same-parity 1 2 3 4 5 6 7)
+(same-parity 2 3 4 5 6 7)
diff --git a/coding-exercises/2/21.rkt b/coding-exercises/2/21.rkt
new file mode 100644
index 0000000..9ad880c
--- /dev/null
+++ b/coding-exercises/2/21.rkt
@@ -0,0 +1,15 @@
+#lang racket
+(require sicp)
+(require "../../shared/chapter1.rkt")
+
+(define (square-list items)
+  (if (null? items)
+    (list)
+    (cons (square (car items)) (square-list (cdr items)))))
+
+(square-list (list 1 2 3 4))
+
+(define (square-list items)
+  (map square items))
+
+(square-list (list 1 2 3 4))
diff --git a/coding-exercises/2/22.rkt b/coding-exercises/2/22.rkt
new file mode 100644
index 0000000..09ace8c
--- /dev/null
+++ b/coding-exercises/2/22.rkt
@@ -0,0 +1,36 @@
+#lang racket
+(require sicp)
+(require "../../shared/chapter1.rkt")
+
+;; Here we are iterating forward, while consing in reverse, this would be a good way to reverse a list
+;; The difference is that iterating is like going forward and recursing is like going backwards.
+;; Recursing works because it is going in reverse and we also need to cons in reverse.
+(define (square-list items)
+  (define (iter things answer)
+    (if (null? things)
+      answer
+      (iter (cdr things)
+            (cons (square (car things))
+                  answer))))
+  (iter items nil))
+;; (square-list (list 1 2 3 4))
+
+;; This attempts the reverse the consing direction by chaning the first in the pair with the second 
+;; The result is that we get pairs that point to other pairs with car, which is not how a list works.
+(define (square-list2 items)
+  (define (iter things answer)
+    (if (null? things)
+      answer
+      (iter (cdr things)
+            (cons answer (square (car things))))))
+  (iter items nil))
+;;(square-list2 (list 1 2 3 4))
+
+;; One thing we could try is also growing the answer list forward somehow
+(define (square-list3 items)
+  (define (iter things answer)
+    (if (null? things)
+      answer
+      (iter (cdr things) (append answer (list (square (car things)))))))
+  (iter items (list)))
+(square-list3 (list 1 2 3 4))
diff --git a/coding-exercises/2/23.rkt b/coding-exercises/2/23.rkt
new file mode 100644
index 0000000..f0df068
--- /dev/null
+++ b/coding-exercises/2/23.rkt
@@ -0,0 +1,14 @@
+#lang racket
+(require sicp)
+
+(define (for-each action items)
+  (define (iter things)
+    (action (car things))
+    (if (not (null? (cdr things)))
+      (iter (cdr things))))
+  (iter items))
+
+(for-each (lambda (x) (newline) (display x))
+          (list 1 2 3 4 5))
+      
+  
diff --git a/coding-exercises/2/24.rkt b/coding-exercises/2/24.rkt
new file mode 100644
index 0000000..575d0cd
--- /dev/null
+++ b/coding-exercises/2/24.rkt
@@ -0,0 +1,10 @@
+#lang racket
+(require sicp)
+
+(define (count-leaves x)
+  (cond ((null? x ) 0)
+        ((not (pair? x)) 1)
+        (else (+ (count-leaves (car x)) 
+                 (count-leaves (cdr x))))))
+
+(list 1 (list 2 (list 3 4)))
diff --git a/coding-exercises/2/25.rkt b/coding-exercises/2/25.rkt
new file mode 100644
index 0000000..beeacc4
--- /dev/null
+++ b/coding-exercises/2/25.rkt
@@ -0,0 +1,9 @@
+#lang racket
+(define a (list 1 3 (list 5 7) 9))
+(car (cdr (car (cdr (cdr a)))))
+
+(define b (list (list 7)))
+(car (car b))
+
+(define c (list 1 (list 2 (list 3 (list 4 (list 5 (list 6 (list 7))))))))
+(car (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr (car (cdr c)))))))))))))
diff --git a/coding-exercises/2/27.rkt b/coding-exercises/2/27.rkt
new file mode 100644
index 0000000..b52f7b3
--- /dev/null
+++ b/coding-exercises/2/27.rkt
@@ -0,0 +1,28 @@
+#lang racket
+(require sicp)
+
+(define (reverse l)
+  (define (iter l p)
+   (cond
+     ((null? l) p)
+     (else
+      (iter
+        (cdr l)
+        (cons (car l) p)))))
+  (iter l (list)))
+
+(define (deep-reverse nested-list)
+  (define (iter l p)
+   (cond
+     ((null? l) p)
+     ((pair? (car l))
+      (iter (cdr l)
+            (cons (iter (car l) nil)
+                  p)))
+     (else
+      (iter
+        (cdr l)
+        (cons (car l) p)))))
+  (iter nested-list nil))
+
+(deep-reverse (list (list 1 2) (list 3 4)))
diff --git a/coding-exercises/2/28.rkt b/coding-exercises/2/28.rkt
new file mode 100644
index 0000000..d8d3bd6
--- /dev/null
+++ b/coding-exercises/2/28.rkt
@@ -0,0 +1,14 @@
+#lang racket
+(require sicp)
+
+(define (fringe tree)
+  (define (iter tree leaves-list)
+    (cond ((null? tree) leaves-list)
+          ((pair? (car tree))
+           (iter (cdr tree) (append leaves-list (iter (car tree) '()))))
+          (else
+           (iter (cdr tree) (append leaves-list (list (car tree)))))))
+  (iter tree '()))
+
+(define x (list (list 1 2) (list 3 4)))
+(fringe x)
diff --git a/coding-exercises/2/29.rkt b/coding-exercises/2/29.rkt
new file mode 100644
index 0000000..8b9138b
--- /dev/null
+++ b/coding-exercises/2/29.rkt
@@ -0,0 +1,8 @@
+#lang racket
+(require sicp)
+
+(define (make-mobile left right)
+  (list left right))
+
+(define (make-branch len structure)
+  (list len structure))
diff --git a/shared/lists.rkt b/shared/lists.rkt
index 9279a57..d5cfc61 100644
--- a/shared/lists.rkt
+++ b/shared/lists.rkt
@@ -1,9 +1,4 @@
 #lang racket
-(provide
-  append
-  length
-  list-ref)
-
 (define (append list1 list2)
   (if (null? list1)
     list2
@@ -19,9 +14,10 @@
 (define (list-ref items n)
   (if (= n 0)
     (car items)
-    (list-ref 
-      (cdr items) 
+    (list-ref
+      (cdr items)
       (- 1 n))))
+
 (define (last-pair l)
   (if (null? (cdr l))
     l