All completed

src/looping_is_recursion.clj

@@ -1,26 +1,73 @@
 (ns looping-is-recursion)
 
 (defn power [base exp]
-  ":(")
+  (let [helper (fn [acc n]
+                 (if (zero? n)
+                   acc
+                   (recur (* acc base) (dec n))))]
+    (helper 1 exp)))
 
 (defn last-element [a-seq]
-  ":(")
+  (let [helper (fn [a-seq]
+                 (if (empty? (rest a-seq))
+                   (first a-seq)
+                   (recur (rest a-seq))))]
+    (helper a-seq)))
 
 (defn seq= [seq1 seq2]
-  ":(")
+  (let [helper (fn [a b]
+                 (cond
+                   (or (empty? a) (empty? b))
+                     (if (and (empty? a) (empty? b))
+                       true
+                       false)
+                   (== (first a) (first b))
+                     (recur (rest a) (rest b))
+                   :else false))]
+    (helper seq1 seq2)))
 
 (defn find-first-index [pred a-seq]
-  ":(")
+  (loop [acc 0 a a-seq]
+    (cond
+      (empty? a)
+        nil
+      (pred (first a))
+        acc
+      :else (recur (inc acc) (rest a)))))
 
 (defn avg [a-seq]
-  -1)
+  (loop [acc 0 size 0 new-seq a-seq]
+    (cond
+      (empty? new-seq)
+        (if (< 0 size) (/ acc size) 0)
+      :else (recur (+ acc (first new-seq)) (inc size) (rest new-seq)))))
 
 (defn parity [a-seq]
-  ":(")
+  (let [toggle (fn [a-set elem]
+                 (if (contains? a-set elem)
+                   (disj a-set elem)
+                   (conj a-set elem)))]
+  (loop [result #{} new-seq a-seq]
+    (if (empty? new-seq)
+      result
+      (recur (toggle result (first new-seq)) (rest new-seq))))))
 
 (defn fast-fibo [n]
-  ":(")
+  (cond
+    (== 0 n)
+      0
+    (== 1 n)
+      1
+    :else (loop [fn-1 1 fn-2 0 at 2]
+            (if (== at n)
+              (+ fn-1 fn-2)
+              (recur (+ fn-1 fn-2) fn-1 (inc at))))))
 
 (defn cut-at-repetition [a-seq]
-  [":("])
-
+  (loop [result [] checker #{} new-seq a-seq]
+    (cond
+      (empty? new-seq)
+        result
+      (contains? checker (first new-seq))
+        result
+      :else (recur (conj result (first new-seq)) (conj checker (first new-seq)) (rest new-seq)))))