2 (:refer-clojure :exclude (map remove))
3 (:use [sicp [ch1-2 :only (fib prime?)]]
13 (def one-thru-four (list 1 2 3 4))
14 ;;=> #'user/one-thru-four
19 (cons 10 one-thru-four)
21 (cons 5 one-thru-four)
24 ;; get nth element of a list
25 (defn list-ref [items n]
28 (list-ref (rest items) (- n 1))))
30 (list-ref one-thru-four 3)
32 (list-ref one-thru-four 5)
34 (list-ref one-thru-four 1)
36 (list-ref one-thru-four 0)
42 (+ 1 (length (rest items)))))
44 (length one-thru-four)
47 (defn- length-i [items n]
50 (length-i (rest items) (+ 1 n))))
52 (defn length-iter [items]
55 (length-iter one-thru-four)
58 (defn append [list1 list2]
62 (append (rest list1) list2))))
64 (append one-thru-four one-thru-four)
65 ;;=> (1 2 3 4 1 2 3 4)
68 (defn scale-list [items factor]
71 (cons (* factor (first items))
72 (scale-list (rest items) factor))))
74 (defn map [proc items]
77 (cons (proc (first items))
78 (map proc (rest items)))))
80 (defn scale-list-with-map [items factor]
81 (map (fn [item] (* item factor)) items))
84 (def x (cons (list 1 2) (list 3 4)))
90 (defn count-leaves [coll]
93 :else (+ (count-leaves (first coll))
94 (count-leaves (next coll)))))
97 (defn scale-tree [tree factor]
99 (not (seq? tree)) (* tree factor)
100 :else (cons (scale-tree (first tree) factor)
101 (scale-tree (next tree) factor))))
104 (defn scale-tree-with-map [tree factor]
107 (scale-tree-with-map sub-tree factor)
108 (* sub-tree factor)))
112 (defn sum-odd-squares [tree]
114 (not (seq? tree)) (if (odd? tree)
115 ((fn [x] (* x x)) tree)
117 :else (+ (sum-odd-squares (first tree))
118 (sum-odd-squares (next tree)))))
121 (letfn [(next-fib [k]
126 (cons f (next-fib (+ k 1)))
127 (next-fib (+ k 1))))))]
130 (map #(* % %) (list 1 2 3 4 5))
132 (defn myfilter-1 [pred? xs]
134 (not (seq? xs)) (if (pred? xs)
137 :else (concat (myfilter-1 pred? (first xs))
138 (myfilter-1 pred? (next xs)))))
140 (defn myfilter-2 [pred? xs]
142 (pred? (first xs)) (cons (first xs)
143 (myfilter-2 pred? (next xs)))
144 :else (myfilter-1 pred? (next xs))))
147 (defn accumulate [op init xs]
151 (accumulate op init (next xs)))))
153 (defn enumerate-interval
155 (enumerate-interval 0 high))
159 (cons low (enumerate-interval (+ low 1) high)))))
161 ;; same as flatten/fringe
162 (defn enumerate-tree [tree]
163 (cond (nil? tree) nil
164 (not (seq? tree)) (list tree)
165 :else (concat (enumerate-tree (first tree))
166 (enumerate-tree (next tree)))))
168 (defn square [x] (* x x))
170 ;; define sum of odd squares in terms of myfilter-2, enumerate, accumulate
171 (defn sum-of-odd-squares [tree]
178 (deftest test-sum-of-odd-squares
179 (is [= (sum-of-odd-squares '((1) (2) (3 4) ((5) (((6) (7)) (8)))))
180 (reduce + (map #(* % %) (filter odd? (range 1 9))))]))
182 (defn even-fibs-new [n]
184 (enumerate-interval ,,,)
187 (accumulate cons nil ,,,)))
189 (defn list-fib-squares [n]
191 (enumerate-interval ,,,)
194 (accumulate cons nil ,,,)))
196 (defn product-of-squares-of-odd-elements [sequence]
200 (filter odd? sequence))))
202 ;; note how beautiful and clear the clojure ->> macro is!
203 (defn product-of-squares-of-odd-elements [sequence]
207 (accumulate * 1 ,,,)))
213 (map (fn [j] (list i j))
214 (enumerate-interval 1 (- i 1))))
215 (enumerate-interval 1 6)))
217 (defn flatmap [proc xs]
218 (accumulate append nil (map proc xs)))
220 (defn prime-sum? [pair]
221 (prime? (+ (first pair)
222 (first (rest pair)))))
224 ;;; create the triple (i,j,sum)
225 (defn make-pair-sum [pair]
229 (first (rest pair)))))
231 (defn prime-sum-pairs [n]
235 (map (fn [j] (list i j))
236 (enumerate-interval 1 (- i 1))))
237 (enumerate-interval 1 n)))))
240 (defn remove [item sequence]
241 (filter (fn [x] (not= item x)) sequence))
243 (defn permutations [s]
247 (map (fn [p] (cons x p))
248 (permutations (remove x s))))