looping lab code

src/solutions/looping.clj

@@ -0,0 +1,78 @@
+(ns solutions.looping)
+
+(defn zipm-1
+  [keys vals]
+  (loop [m {}
+         ks (seq keys)
+         vs (seq vals)]
+    (if (and ks vs)
+      (recur (assoc m (first ks) (first vs))
+             (next ks)
+             (next vs))
+      m)))
+
+(defn zipm-2
+  [keys vals]
+  (loop [m {} 
+       [k & ks :as keys] (seq keys) 
+       [v & vs :as vals] (seq vals)]
+  (if (and keys vals)
+    (recur (assoc m k v) ks vs)
+    m)))
+
+(defn zipm-3
+  [keys vals]
+  (reduce (fn [m [k v]] (assoc m k v)) 
+          {} (map vector keys vals)))
+
+(defn zipm-4
+  [keys vals]
+  (apply hash-map (interleave keys vals)))
+
+(defn zipm-5
+  [keys vals]
+  (into {} (map vector keys vals)))
+
+(defn min-1
+  [x & more]
+  (loop [min x
+         more (seq more)]
+    (if-let [x (first more)]
+      (recur (if (< x min) x min) (rest more))
+      min)))
+
+(defn min-2
+  [x & more]
+  (loop [min x
+         [x & more] (seq more)]
+    (if x
+      (recur (if (< x min) x min) (rest more))
+      min)))
+
+(defn min-3
+  [& coll]
+  (reduce
+   (fn [x y] (if (< x y) x y))
+   coll))
+
+(defn minmax-1
+  [x & more]
+  (loop [min x
+         max x
+         [x & more] (seq more)]
+    (if x
+      (recur
+       (if (< x min) x min)
+       (if (> x max) x max)
+       more)
+      {:min min :max max})))
+
+(defn minmax-2
+  [x & more]
+  (reduce
+   (fn [result x]
+     (-> result
+         (merge-with :min x min)
+         (merge-with :max x max)))
+   {:min x :max x}
+   more))

test/solutions/looping_test.clj

@@ -0,0 +1,32 @@
+(ns solutions.looping-test
+  (:use circumspec solutions.looping))
+
+(testing "zipm"
+  (for-these [result keys vals]
+    (should (= result
+               (zipm-1 keys vals)
+               (zipm-2 keys vals)
+               (zipm-3 keys vals)
+               (zipm-4 keys vals)
+               (zipm-5 keys vals)
+               (zipmap keys vals)))
+    {} nil nil
+    {:a 1} [:a] [1]
+    {:a 2} [:a :a] [1 2]))
+
+(testing "min"
+  (for-these [result vals]
+    (should (= result
+               (apply min-1 vals)
+               (apply min-2 vals)
+               (apply min-3 vals)
+               (apply min vals)))
+    2 [6 2 4]
+    0 [0]))
+
+(testing "minmax"
+  (for-these [result vals]
+    (should (= result
+               (apply minmax-1 vals)))
+    {:min 2 :max 7} [7 2 4]
+    {:min 0 :max 0} [0]))