From 2792209aa6ec357ba0a4ac9d4791525a87d9a7a5 Mon Sep 17 00:00:00 2001 From: Olli Date: Mon, 31 Jul 2017 16:54:57 +0300 Subject: [PATCH 1/2] test --- src/recursion.clj | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/recursion.clj b/src/recursion.clj index 95d77aa..dbe839f 100644 --- a/src/recursion.clj +++ b/src/recursion.clj @@ -1,10 +1,16 @@ (ns recursion) (defn product [coll] - :-) + (if (empty? coll) + 1 + (* (first coll) + (product (rest coll))))) (defn singleton? [coll] - :-) + (if (and (not (empty? coll)) + (empty? (rest coll))) + true + false)) (defn my-last [coll] :-) From 1c7fe823a571c56022c475b0e1e9f2d6338b8893 Mon Sep 17 00:00:00 2001 From: Olli Date: Mon, 31 Jul 2017 17:52:25 +0300 Subject: [PATCH 2/2] All but one completed. --- src/recursion.clj | 158 ++++++++++++++++++++++++++++++++++++++-------- 1 file changed, 130 insertions(+), 28 deletions(-) diff --git a/src/recursion.clj b/src/recursion.clj index dbe839f..8297535 100644 --- a/src/recursion.clj +++ b/src/recursion.clj @@ -13,86 +13,188 @@ false)) (defn my-last [coll] - :-) + (if (or (singleton? coll) (empty? coll)) + (first coll) + (my-last (rest coll)))) (defn max-element [a-seq] - :-) + (if (or (singleton? a-seq) (empty? a-seq)) + (first a-seq) + (max (first a-seq) (max-element (rest a-seq))))) (defn seq-max [seq-1 seq-2] - [:-]) + (if (<= (count seq-1) (count seq-2)) + seq-2 + seq-1)) (defn longest-sequence [a-seq] - [:-]) + (if (or (singleton? a-seq) (empty? a-seq)) + (first a-seq) + (seq-max (first a-seq) + (longest-sequence (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 + (not (= elem (first a-seq))) + (sequence-contains? elem (rest a-seq)) + :else true)) (defn my-take-while [pred? a-seq] - [:-]) + (cond + (empty? a-seq) + () + (pred? (first a-seq)) + (cons (first a-seq) (my-take-while pred? (rest a-seq))) + :else ())) (defn my-drop-while [pred? a-seq] - [:-]) + (cond + (empty? a-seq) + () + (pred? (first a-seq)) + (my-drop-while pred? (drop 1 a-seq)) + :else 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 + (== (first a-seq) (first b-seq)) + (seq= (rest a-seq) (rest b-seq)) + :else false)) (defn my-map [f seq-1 seq-2] - [:-]) + (cond + (or (empty? seq-1) (empty? seq-2)) () + :else (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] - :-) + (cond + (zero? n) 0 + (== 1 n) 1 + (== 2 n) 1 + :else (+ (fib (dec n)) (fib (dec (dec n)))))) (defn my-repeat [how-many-times what-to-repeat] - [:-]) + (cond + (< 0 how-many-times) + (cons what-to-repeat (my-repeat (dec how-many-times) what-to-repeat)) + :else ())) (defn my-range [up-to] - [:-]) + (cond + (< 0 up-to) + (cons (dec up-to) (my-range (dec up-to))) + :else ())) (defn tails [a-seq] - [:-]) + (cond + (empty? a-seq) + (cons a-seq ()) + :else (cons (seq a-seq) (tails (rest a-seq))))) (defn inits [a-seq] - [:-]) + (map reverse (tails (reverse a-seq)))) (defn rotations [a-seq] - [:-]) + (cond (empty? a-seq) (concat [] [()]) + :else (take (count a-seq) (partition (count a-seq) 1 (cycle a-seq))))) (defn my-frequencies-helper [freqs a-seq] - [:-]) + (if (empty? a-seq) + freqs + (if (not (contains? freqs (first a-seq))) + (let [new-freqs (assoc freqs (first a-seq) 1)] + (my-frequencies-helper new-freqs (rest a-seq))) + (my-frequencies-helper + (assoc freqs (first a-seq) (inc (get freqs (first a-seq)))) + (rest a-seq))))) (defn my-frequencies [a-seq] - [:-]) + (my-frequencies-helper {} a-seq)) + +(defn un-frequencies-helper [result a-map] + (if (empty? a-map) + result + (let [[key value] (first a-map)] + (let [new-result (concat result (repeat value key))] + (un-frequencies-helper new-result (rest a-map)))))) (defn un-frequencies [a-map] - [:-]) + (un-frequencies-helper [] a-map)) (defn my-take [n coll] - [:-]) + (cond + (not (empty? coll)) + (if (not (zero? n)) + (cons (first coll) (my-take (dec n) (rest coll)))))) (defn my-drop [n coll] - [:-]) + (cond + (empty? coll) + coll + (zero? n) + coll + :else (my-drop (dec n) (rest coll)))) (defn halve [a-seq] - [:-]) + (let [mid (int (/ (count a-seq) 2))] + (if (== 0 mid) + (vector () (cons (first a-seq) ())) + (vector (my-take mid a-seq) (my-drop mid a-seq))))) (defn seq-merge [a-seq b-seq] - [:-]) + (cond + (and (empty? a-seq) (empty? b-seq)) + a-seq + (or (empty? a-seq) (empty? b-seq)) + (if (empty? a-seq) + (cons (first b-seq) (seq-merge a-seq (rest b-seq))) + (cons (first a-seq) (seq-merge (rest a-seq) b-seq))) + (<= (first a-seq) (first b-seq)) + (cons (first a-seq) (seq-merge (rest a-seq) b-seq)) + (<= (first b-seq) (first a-seq)) + (cons (first b-seq) (seq-merge a-seq (rest b-seq))))) (defn merge-sort [a-seq] - [:-]) + (cond + (>= 1 (count a-seq)) + (into () a-seq) + :else (let [[first-halve rest-halve] (halve a-seq)] + (seq-merge + (merge-sort first-halve) + (merge-sort rest-halve))))) (defn split-into-monotonics [a-seq] [:-]) -(defn permutations [a-set] - [:-]) +(defn permutations [colls] + (if (empty? colls) + '(()) + (if (= 1 (count colls)) + (list colls) + (for [head colls + tail (permutations (disj (set colls) head))] + (cons head tail))))) (defn powerset [a-set] - [:-]) + (cond + (empty? a-set) (hash-set (hash-set)) + :else (clojure.set/union (powerset (next a-set)) + (map #(conj % (first a-set)) (powerset (next a-set))))))