Sixth set almost done

src/recursion.clj

@@ -1,52 +1,104 @@
 (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]
- :-)
+ (if (singleton? coll)
+ (apply int coll)
+ (my-last (rest coll))))
 
 (defn max-element [a-seq]
- :-)
+ (let [fst (first a-seq)
+ rst (rest a-seq)]
+ (if (empty? rst)
+ fst
+ (max fst (max-element rst)))))
 
 (defn seq-max [seq-1 seq-2]
- [:-])
+ (cond
+ (<= (count seq-1) (count seq-2)) seq-2
+ :else seq-1
+ ))
 
 (defn longest-sequence [a-seq]
- [:-])
+ (let [fst (first a-seq)
+ rst (rest a-seq)]
+ (if (empty? rst)
+ fst
+ (seq-max fst (longest-sequence rst)))))
 
 (defn my-filter [pred? a-seq]
- [:-])
+ (lazy-seq
+ (when (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
+ (not(= elem (first a-seq)))
+ (sequence-contains? elem (rest a-seq))
+ :else
+ true))
 
 (defn my-take-while [pred? a-seq]
- [:-])
+ (lazy-seq
+ (when (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]
- [:-])
+ (lazy-seq
+ (when (seq a-seq)
+ (if (pred? (first a-seq))
+ (my-drop-while pred? (rest a-seq))
+ a-seq
+
+ ))))
 
 (defn seq= [a-seq b-seq]
- :-)
+ (cond
+ (not(= (count (rest a-seq)) (count (rest b-seq)))) false
+ (and (empty? a-seq) (empty? b-seq)) true
+ (= (first a-seq)( first b-seq)) (seq= (rest a-seq) (rest b-seq))
+ :else false))
 
 (defn my-map [f seq-1 seq-2]
- [:-])
+ (if (or (empty? seq-1) (empty? seq-2))
+ '()
+ (cons (f (first seq-1) (first seq-2))
+ (my-map f (rest seq-1) (rest seq-2)))))
 
 (defn power [n k]
- :-)
+ (if (zero? k)
+ 1
+ (* n (power n (dec k)))))
 
 (defn fib [n]
- :-)
+ (if (< n 2)
+ n
+ (+ (fib (- n 1))
+ (fib (- n 2)))))
 
 (defn my-repeat [how-many-times what-to-repeat]
- [:-])
+ (if (zero? how-many-times)
+ what-to-repeat
+ (cons (my-repeat (dec how-many-times) what-to-repeat) what-to-repeat)))
 
 (defn my-range [up-to]
- [:-])
+ (if (zero? up-to)
+ ()
+ (cons (my-range (dec up-to)) (up-to)))
 
 (defn tails [a-seq]
  [:-])