Remek

spec/euler/level1/bowling_spec.clj

@@ -0,0 +1,31 @@
+(ns euler.level1.bowling-spec
+  (:use
+    [speclj.core]
+    [euler.level1.bowling]))
+
+(describe "Bowling Game "
+
+  (it "gutter game - no pins scores 0"
+    (should= 0 (score (repeat 0))))
+
+  (it "all 1s - score is sum of pins"
+    (should= 20 (score (repeat 1))))
+
+  (it "spare adds the next roll"
+    (should= 16 (score [4 6 3])))
+
+  (it "strike add next two rolls"
+    (should= 16 (score [10 1 2])))
+
+  (it "perfect game - all strikes"
+    (should= 300 (score (repeat 10))))
+
+  (it "->frames"
+    (should= [] (->frames []))
+    (should= [[1]] (->frames [1]))
+    (should= [[1 2][3 4]] (->frames [1 2 3 4]))
+    (should= [[4 6 3][3]] (->frames [4 6 3]))
+    (should= [[10 1 2][1 2]] (->frames [10 1 2])))
+  )
+
+(run-specs)

spec/euler/level1/problem001_spec.clj

@@ -7,9 +7,19 @@
 
 (describe "Euler Problem #1"
 
+  (it "finds multiples of 3 and 5"
+    (should= false (multiple-of-3-or-5? 1))
+    (should= true (multiple-of-3-or-5? 3))
+    (should= true (multiple-of-3-or-5? 10))
+    )
+
   (it "Solves #1"
     (should= 23 (euler-1 10))
-	(should= -1 (euler-1 1000)))
+    (should= 3 (euler-1 4))
+    (should= 8 (euler-1 6))
+    (should= 33 (euler-1 11))
+    (should= 233168 (euler-1 1000))
+    )
   )
 
 (run-specs)

spec/euler/level1/problem002_spec.clj

@@ -0,0 +1,28 @@
+(ns euler.level1.problem002-spec
+  (:require
+    [speclj.core :refer :all]
+    [euler.level1.problem002 :refer :all]))
+
+; https://projecteuler.net/problem=2
+
+(describe "Euler Problem #2"
+
+  (it "fib"
+    (should= '(1) (fib 1))
+    (should= '(1 2) (fib 2))
+    (should= '(1 2 3) (fib 3))
+    (should= '(1 2 3 5) (fib 4))
+    (should= '(1 2 3 5 8 13) (fib 6))
+    (should= 3524578 (last (fib 32)))
+    (should= 5702887 (last (fib 33)))
+    )
+
+  (it "euler-2"
+    (should= 4613732 (euler-2 32))
+    )
+
+  )
+
+
+
+(run-specs)

spec/euler/level1/problem003_spec.clj

@@ -0,0 +1,17 @@
+(ns euler.level1.problem003-spec
+  (:require
+    [speclj.core :refer :all]
+    [euler.level1.problem003 :refer :all]))
+
+; https://projecteuler.net/problem=3
+
+(describe "Euler Problem #3"
+
+  (it "Solves #3"
+    (should= 7 (euler-3 7))
+    (should= 29 (euler-3 13195))
+    (should= 6857 (euler-3 600851475143))
+    )
+  )
+
+(run-specs)

spec/euler/level1/problem004_spec.clj

@@ -0,0 +1,21 @@
+(ns euler.level1.problem004-spec
+  (:require
+    [speclj.core :refer :all]
+    [euler.level1.problem004 :refer :all]))
+
+; https://projecteuler.net/problem=4
+
+(describe "Euler Problem #4"
+
+  (it "palindrome?"
+    (should= false (palindrome? 21))
+    (should= true (palindrome? 1))
+    (should= true (palindrome? 121)))
+
+  (it "Solves #4"
+    (should= 9009 (euler-4 2))
+    (should= 906609 (euler-4 3))
+    )
+  )
+
+(run-specs)

spec/euler/level1/problem005_spec.clj

@@ -0,0 +1,22 @@
+(ns euler.level1.problem005-spec
+  (:require
+    [speclj.core :refer :all]
+    [euler.level1.problem005 :refer :all]))
+
+; https://projecteuler.net/problem=5
+
+(describe "Euler Problem #5"
+
+  (it "divisible"
+    (should= true (divisible? 10 [2 5]))
+    (should= false (divisible? 10 [3 5]))
+    (should= true (divisible? 2520 [2 3 4 5 6 7 8 9 10]))
+    )
+
+  (it "Solves #5"
+    (should= 2520 (euler-5 10))
+    (should= 232792560 (euler-5 20))
+    )
+  )
+
+(run-specs)

spec/euler/level1/problem006_spec.clj

@@ -0,0 +1,15 @@
+(ns euler.level1.problem006-spec
+  (:require
+    [speclj.core :refer :all]
+    [euler.level1.problem006 :refer :all]))
+
+; https://projecteuler.net/problem=6
+
+(describe "Euler Problem #6"
+
+  (it "Solves #6"
+    (should= 2640 (euler-6 10))
+    (should= 25164150 (euler-6 100)))
+  )
+
+(run-specs)

spec/euler/level1/problem007_spec.clj

@@ -0,0 +1,32 @@
+(ns euler.level1.problem007-spec
+  (:require
+    [speclj.core :refer :all]
+    [euler.level1.problem007 :refer :all]))
+
+; https://projecteuler.net/problem=7
+
+(describe "Euler Problem #7"
+
+  (it "prime"
+    (should= true (prime? 1))
+    (should= true (prime? 2))
+    (should= true (prime? 3))
+    (should= false (prime? 4))
+    (should= false (prime? 6))
+    (should= false (prime? 9))
+    )
+
+  (it "next-prime"
+    (should= 7 (next-prime 5))
+    (should= 3 (next-prime 2))
+    (should= 11 (next-prime 7))
+    )
+
+  (it "Solves #7"
+    (should= 13 (euler-7 6))
+    ;(should= 104743 (euler-7 10001))
+    )
+
+  )
+
+(run-specs)

spec/euler/level1/problem008_spec.clj

@@ -0,0 +1,26 @@
+(ns euler.level1.problem008-spec
+  (:require
+    [speclj.core :refer :all]
+    [euler.level1.problem008 :refer :all]))
+
+; https://projecteuler.net/problem=8
+
+(describe "Euler Problem #8"
+
+  (it "segment-by-digits"
+    (should= "7316" (first (segment-by-digits 4)))
+    (should= "3167" (second (segment-by-digits 4)))
+    (should= "3450" (last (segment-by-digits 4)))
+    )
+
+  (it "digits-product"
+    (should= (* 2 3 4) (digits-product 234))
+    )
+
+  (it "Solves #8"
+    (should= 5832 (euler-8 4))
+    (should= 23514624000 (euler-8 13))
+    )
+  )
+
+(run-specs)

src/euler/level1/bowling.clj

@@ -0,0 +1,24 @@
+(ns euler.level1.bowling)
+
+(defn sum [nums]
+  (reduce + nums))
+
+(defn spare? [rolls]
+  (= (sum (take 2 rolls)) 10))
+
+(defn strike? [rolls]
+  (= (first rolls) 10))
+
+(defn ->frames [rolls]
+  (if (empty? rolls)
+    []
+    (cons
+      (if (or (spare? rolls) (strike? rolls))
+        (take 3 rolls)
+        (take 2 rolls))
+      (lazy-seq (->frames (if (strike? rolls)
+                            (drop 1 rolls)
+                            (drop 2 rolls)))))))
+
+(defn score [rolls]
+  (sum (flatten (take 10 (->frames rolls)))))

src/euler/level1/problem001.clj

@@ -1,4 +1,10 @@
 (ns euler.level1.problem001)
 
-(defn euler-1 [n]
+(defn multiple-of-3-or-5? [n]
+  (or (zero? (mod n 3)) (zero? (mod n 5)))
   )
+
+(defn euler-1 [n]
+  (->> (range n)
+       (filter multiple-of-3-or-5?)
+       (apply +)))

src/euler/level1/problem002.clj

@@ -0,0 +1,13 @@
+(ns euler.level1.problem002)
+
+
+(defn fib [n]
+  (->> [0 1]
+       (iterate (fn [[a b]] [b (+ a b)]))
+       (map first)
+       (drop 2)
+       (take n)))
+
+(defn euler-2 [n]
+  (reduce + (filter even? (fib n)))
+  )

src/euler/level1/problem003.clj

@@ -0,0 +1,16 @@
+(ns euler.level1.problem003)
+
+(defn smallest-factor [n]
+  (first (filter
+            (fn[x] (= (mod n x) 0))
+            ;#(= (mod n %) 0)
+            (iterate inc 2))))
+
+(defn factorize [n]
+  (let [other (/ n (smallest-factor n))]
+    (if (= other 1)
+      n
+      (factorize other))))
+
+(defn euler-3 [n]
+  (factorize n))

src/euler/level1/problem004.clj

@@ -0,0 +1,26 @@
+(ns euler.level1.problem004)
+
+(defn palindrome? [s]
+  (let [s (str s)
+        len (count s)
+        last (dec len)]
+    ;(= (seq s) (reverse s))
+    (if (<= len 1)
+      true
+      (and
+        (= (get s 0) (get s last))
+        (palindrome? (subs s 1 last))))))
+
+(defn products-of-n-digit-numbers [n]
+  (let [n-digit-nos
+        (range
+          (int (Math/pow 10 (- n 1)))
+          (int (Math/pow 10 n)))]
+    (flatten
+      (map (fn [x]
+             (map (fn [y] (* x y)) n-digit-nos)) n-digit-nos))))
+
+(defn euler-4 [n]
+    (reduce
+      max
+      (filter palindrome? (products-of-n-digit-numbers n))))

src/euler/level1/problem005.clj

@@ -0,0 +1,41 @@
+(ns euler.level1.problem005)
+
+(defn take-until
+  "Returns a lazy sequence of successive items from coll until
+   (pred item) returns true, including that item. pred must be
+   free of side-effects."
+  [pred coll]
+  (lazy-seq
+    (when-let [s (seq coll)]
+      (if (pred (first s))
+        (cons (first s) nil)
+        (cons (first s) (take-until pred (rest s)))))))
+
+(defn divisible? [o divisors]
+  (if (= o 0)
+    false
+    (=
+      (count divisors)
+      (count
+        (filter
+          zero?
+          (map
+            (fn [divisor]
+              (mod o divisor)) divisors)
+          )
+        )
+      )
+    )
+  )
+
+
+(defn euler-5 [n]
+  (let [divisors (range 1 (+ n 1))]
+    (last
+      (take-until
+        (fn [n]
+          (divisible? n divisors))
+        (iterate (fn [x] (+ x 210)) 0))
+      )
+    )
+  )

src/euler/level1/problem006.clj

@@ -0,0 +1,16 @@
+(ns euler.level1.problem006)
+
+(defn square [n]
+  (Math/pow n 2))
+
+(defn euler-6 [n]
+  (let [r (map inc (range n))]
+    (int (-
+      (square
+        (reduce + r))
+      (reduce +
+              (map square r)
+              )
+      )
+    ))
+  )