diff --git a/.travis.yml b/.travis.yml index 455f3c0..45c29f6 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,6 +1,6 @@ language: clojure -lein: lein2 -script: lein2 midje :config .midje-grading-config.clj +lein: lein +script: lein midje :config .midje-grading-config.clj jdk: - openjdk7 notifications: diff --git a/project.clj b/project.clj index 1688f3e..66edab9 100644 --- a/project.clj +++ b/project.clj @@ -1,4 +1,4 @@ (defproject recursion "1.0.0-SNAPSHOT" - :dependencies [[org.clojure/clojure "1.5.1"] + :dependencies [[org.clojure/clojure "1.8.0"] [iloveponies.tests/recursion "0.1.0-SNAPSHOT"]] :profiles {:dev {:plugins [[lein-midje "3.1.1"]]}}) diff --git a/src/recursion.clj b/src/recursion.clj index 95d77aa..1d92e49 100644 --- a/src/recursion.clj +++ b/src/recursion.clj @@ -1,92 +1,213 @@ (ns recursion) (defn product [coll] - :-) + (if (empty? coll) + 1 + (* (first coll) (product (rest coll))))) (defn singleton? [coll] - :-) + (if (empty? coll) + false + (if (empty? (rest coll)) + true + false))) (defn my-last [coll] - :-) + (if (empty? (rest coll)) + (first coll) + (my-last (rest coll)))) (defn max-element [a-seq] - :-) + (if (empty? a-seq) + nil + (if (empty? (rest a-seq)) + (first a-seq) + (max (first a-seq) (max-element (rest a-seq)))))) (defn seq-max [seq-1 seq-2] - [:-]) + (let [seq-1-sz (count seq-1) + seq-2-sz (count seq-2)] + (if (> seq-1-sz seq-2-sz) + seq-1 + seq-2))) (defn longest-sequence [a-seq] - [:-]) + (cond + (empty? a-seq) nil + :else (seq-max (first a-seq) + (longest-sequence (rest a-seq))))) (defn my-filter [pred? a-seq] - [:-]) + (if (empty? 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) + () + (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) + [] + (if (not (pred? (first a-seq))) + a-seq + (my-drop-while pred? (rest a-seq))))) (defn seq= [a-seq b-seq] - :-) + (cond + (not (= (first a-seq) (first b-seq))) false + (and (empty? a-seq) (not (empty? b-seq))) false + (and (not (empty? a-seq)) (empty? 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 true)) (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 power [n k] - :-) + (if (zero? k) + 1 + (* n (power n (dec k))))) (defn fib [n] - :-) + (cond + (or (zero? n) (= n 1)) n + (= n 2) 1 + :else (+ (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] - [:-]) + (if (<= up-to 0) + () + (cons (dec up-to) (my-range (dec up-to))))) (defn tails [a-seq] - [:-]) + (if (empty? a-seq) + (cons a-seq ()) + (cons (map (fn [x] x) a-seq) (tails (rest a-seq))))) (defn inits [a-seq] - [:-]) + (if (empty? a-seq) + (cons a-seq ()) + (cons (reverse (map (fn [x] x) (reverse a-seq))) (inits (reverse (rest (reverse a-seq)))) ))) (defn rotations [a-seq] - [:-]) + (if (empty? a-seq) + '(()) + (rest (map concat (tails a-seq) (reverse (inits a-seq)))))) (defn my-frequencies-helper [freqs a-seq] - [:-]) + (if (empty? a-seq) + freqs + (let [elem (first a-seq) + new-freqs (assoc freqs elem (if (contains? freqs elem) + (inc (get freqs elem)) + 1))] + (my-frequencies-helper new-freqs (rest a-seq))))) (defn my-frequencies [a-seq] - [:-]) + (my-frequencies-helper {} a-seq)) + + +(defn un-frequencies-helper [a-map a-seq] + (if (empty? a-map) + (reverse a-seq) + (let [elem (first (first a-map)) + nr-times (second (first a-map))] + (un-frequencies-helper (into {} (rest a-map)) (concat (repeat nr-times elem) a-seq))))) (defn un-frequencies [a-map] - [:-]) + (un-frequencies-helper a-map '())) + +(defn my-take-helper [n coll a-seq] + (if (empty? coll) + (reverse a-seq) + (if (<= n 0) + (reverse a-seq) + (my-take-helper (dec n) (rest coll) (conj (concat a-seq) (first coll)))))) (defn my-take [n coll] - [:-]) + (my-take-helper n coll '())) (defn my-drop [n coll] - [:-]) + (if (empty? coll) + coll + (if (<= n 0) + coll + (my-drop (dec n) (rest coll))))) (defn halve [a-seq] - [:-]) + (if (empty? a-seq) + a-seq + (let [middle (int (/ (count a-seq) 2))] + (conj [] (my-take middle a-seq) (my-drop middle a-seq))))) + + +(defn seq-merge-helper [a-seq b-seq merged-seq] + (cond + (and (empty? a-seq) (empty? b-seq)) merged-seq + (empty? a-seq) (concat merged-seq b-seq) + (empty? b-seq) (concat merged-seq a-seq) + :else (if (<= (first a-seq) (first b-seq)) + (seq-merge-helper (rest a-seq) b-seq (reverse (conj (reverse merged-seq) (first a-seq)))) + (seq-merge-helper a-seq (rest b-seq) (reverse (conj (reverse merged-seq) (first b-seq))))))) (defn seq-merge [a-seq b-seq] - [:-]) + (seq-merge-helper a-seq b-seq '())) (defn merge-sort [a-seq] - [:-]) + (if (empty? (rest a-seq)) + a-seq + (let [two-halves (halve a-seq) + lo-half (get two-halves 0) + hi-half (get two-halves 1)] + (seq-merge (merge-sort lo-half) (merge-sort hi-half))))) + + + +(defn monotonics-inits-helper [i-seq] + (if (empty? (rest i-seq)) + (first i-seq) + (if (and + (not= (second i-seq) (sort <= (second i-seq))) + (not= (second i-seq) (sort >= (second i-seq)))) + (first i-seq) + (monotonics-inits-helper (rest i-seq))))) + +(defn split-into-monotonics-helper [a-seq m-seq] + (if (empty? a-seq) + (reverse m-seq) + (let [init-seq (rest (reverse (inits a-seq))) + init-monotonic (monotonics-inits-helper init-seq) + nr-monotonic (count init-monotonic)] + (split-into-monotonics-helper (drop nr-monotonic a-seq) (conj m-seq init-monotonic))))) (defn split-into-monotonics [a-seq] - [:-]) + (split-into-monotonics-helper a-seq '())) + + +(defn permutations [a-set]) + -(defn permutations [a-set] - [:-]) +(defn powerset [a-set]) -(defn powerset [a-set] - [:-])