completed more exercises 186b1a7

.travis.yml

@@ -1,8 +1,8 @@
 language: clojure
-lein: lein2
-script: lein2 midje :config .midje-grading-config.clj
+lein: lein
+script: lein midje :config .midje-grading-config.clj
 jdk:
-  - openjdk7
+  - openjdk8
 notifications:
   email: false
   webhooks: http://polar-hollows-8825.herokuapp.com/notifications

src/recursion.clj

@@ -1,86 +1,180 @@
 (ns recursion)
 
 (defn product [coll]
-  :-)
+  (if (empty? coll)
+    1
+    (* (first coll)
+       (product (rest coll)))))
 
 (defn singleton? [coll]
-  :-)
+  (and
+   (not (empty? coll))
+   (empty? (rest coll))))
 
 (defn my-last [coll]
-  :-)
+  (let [[x & xs] coll]
+    (if (empty? xs)
+      x
+      (my-last xs))))
 
 (defn max-element [a-seq]
-  :-)
+  (cond
+   (empty? a-seq) nil
+   (singleton? a-seq) (first a-seq)
+   :else (max (first a-seq) (max-element (rest a-seq)))))
 
 (defn seq-max [seq-1 seq-2]
-  [:-])
+  (if (> (count seq-1) (count seq-2))
+    seq-1
+    seq-2))
 
 (defn longest-sequence [a-seq]
-  [:-])
+  (cond
+   (empty? a-seq) nil
+   (singleton? a-seq) (first a-seq)
+   :else (seq-max (first a-seq) (longest-sequence (rest a-seq)))))
+
+;; sample my-filter should look like my-map
+(defn my-map [f a-seq]
+  (if (empty? a-seq)
+    a-seq
+    (cons (f (first a-seq))
+          (my-map f (rest a-seq)))))
 
 (defn my-filter [pred? a-seq]
-  [:-])
+  (if (empty? a-seq)
+    a-seq
+    (if (pred? (first a-seq))
+      (cons (first a-seq)
+            (my-filter pred? (rest a-seq)))
+      (my-filter pred? (rest a-seq)))))
 
 (defn sequence-contains? [elem a-seq]
-  :-)
+  (cond (empty? a-seq) false
+        (= elem (first a-seq)) true
+        :else (sequence-contains? elem (rest a-seq))))
 
 (defn my-take-while [pred? a-seq]
-  [:-])
+  (if (empty? a-seq)
+    a-seq
+    (if (pred? (first a-seq))
+      (cons (first a-seq)
+            (my-take-while pred? (rest a-seq)))
+      '())))
 
 (defn my-drop-while [pred? a-seq]
-  [:-])
+  (if (empty? a-seq)
+    a-seq
+    (if (pred? (first a-seq))
+      (my-drop-while pred? (rest a-seq))
+      a-seq)))
 
 (defn seq= [a-seq b-seq]
-  :-)
+  (cond (and (empty? a-seq) (empty? b-seq)) true
+        (or (empty? a-seq) (empty? b-seq)) false
+        :else (and (= (first a-seq) (first b-seq))
+                   (seq= (rest a-seq) (rest b-seq)))))
 
 (defn my-map [f seq-1 seq-2]
-  [:-])
+  (if (and (first seq-1) (first seq-2))
+    (cons (f (first seq-1) (first seq-2))
+          (my-map f (rest seq-1) (rest seq-2)))
+    '()))
+
+(defn factorial [n]
+  (if (zero? n)
+    1
+    (* n (factorial (dec n)))))
 
 (defn power [n k]
-  :-)
+  (if (zero? k)
+    1
+    (* n (power n (dec k)))))
 
 (defn fib [n]
-  :-)
+  (if (<= n 1) n
+      (+ (fib (dec n)) (fib (- n 2)))))
 
 (defn my-repeat [how-many-times what-to-repeat]
-  [:-])
+  (if (<= how-many-times 0)
+    ()
+    (cons what-to-repeat (my-repeat (dec how-many-times) what-to-repeat))))
 
 (defn my-range [up-to]
-  [:-])
+  (let [minus-1 (dec up-to)]
+    (if (= up-to 0)
+      ()
+      (cons minus-1 (my-range minus-1)))))
 
 (defn tails [a-seq]
-  [:-])
+  (if (empty? a-seq)
+    (list ())
+    (cons (seq a-seq) (tails (rest a-seq)))))
 
 (defn inits [a-seq]
-  [:-])
+  (reverse (map reverse (tails (reverse a-seq)))))
 
 (defn rotations [a-seq]
-  [:-])
+  (if (empty? a-seq)
+    (list ())
+    (rest (map concat (tails a-seq) (inits a-seq)))))
 
 (defn my-frequencies-helper [freqs a-seq]
-  [:-])
+  (if (empty? a-seq)
+    freqs
+    (let [elem (first a-seq)
+          num (freqs elem)
+          new-freqs (if (number? num)
+                      (assoc freqs elem (+ num 1))
+                      (assoc freqs elem 1))]
+      (my-frequencies-helper new-freqs
+                         (rest a-seq)))))
 
 (defn my-frequencies [a-seq]
-  [:-])
+  (my-frequencies-helper {} a-seq))
 
 (defn un-frequencies [a-map]
-  [:-])
+  (if (empty? a-map)
+    nil
+    (let [entry (first a-map)
+          elem (first entry)
+          n (second entry)]
+      (concat (repeat n elem) (un-frequencies (rest a-map))))))
 
 (defn my-take [n coll]
-  [:-])
+  (cond (= n 0) ()
+        (empty? coll) ()
+        :else (cons (first coll) (my-take (dec n) (rest coll)))))
 
 (defn my-drop [n coll]
-  [:-])
+  (cond (= n 0) coll
+        (empty? coll) ()
+        :else (my-drop (dec n) (rest coll))))
 
 (defn halve [a-seq]
-  [:-])
+  (let [n (int (/ (count a-seq) 2))
+        a (my-take n a-seq)
+        b (my-drop n a-seq)]
+    (list a b)))
 
 (defn seq-merge [a-seq b-seq]
-  [:-])
+  (cond (empty? a-seq) b-seq
+        (empty? b-seq) a-seq
+        :else (let [a (first a-seq)
+                    b (first b-seq)]
+                (if (< a b)
+                  (cons a (seq-merge (rest a-seq) b-seq))
+                  (cons b (seq-merge a-seq (rest b-seq)))))))
 
 (defn merge-sort [a-seq]
-  [:-])
+  (if (<= (count a-seq) 1)
+    a-seq
+    (let [[a b] (halve a-seq)]
+      (seq-merge (merge-sort a) (merge-sort b)))))
+
 
+; Hint: You might find useful the functions take-while, drop and inits.
+; Make sure that your inits returns the prefixes from the shortest to the longest.
 (defn split-into-monotonics [a-seq]
   [:-])