Data commit

Task/Stern-Brocot-sequence/Clojure/stern-brocot-sequence-1.clj

@@ -0,0 +1,34 @@
+;; each step adds two items
+(defn sb-step [v]
+  (let [i (quot (count v) 2)]
+    (conj v (+ (v (dec i)) (v i)) (v i))))
+
+;; A lazy, infinite sequence -- `take` what you want.
+(def all-sbs (sequence (map peek) (iterate sb-step [1 1])))
+
+;; zero-based
+(defn first-appearance [n]
+  (first (keep-indexed (fn [i x] (when (= x n) i)) all-sbs)))
+
+;; inlined abs; rem is slightly faster than mod, and the same result for positive values
+(defn gcd [a b]
+  (loop [a (if (neg? a) (- a) a)
+         b (if (neg? b) (- b) b)]
+    (if (zero? b)
+      a
+      (recur b (rem a b)))))
+
+(defn check-pairwise-gcd [cnt]
+  (let [sbs (take (inc cnt) all-sbs)]
+    (every? #(= 1 %) (map gcd sbs (rest sbs)))))
+
+;; one-based index required by problem statement
+(defn report-sb []
+  (println "First 15 Stern-Brocot members:" (take 15 all-sbs))
+  (println "First appearance of N at 1-based index:")
+  (doseq [n [1 2 3 4 5 6 7 8 9 10 100]]
+    (println " first" n "at" (inc (first-appearance n))))
+  (println "Check pairwise GCDs = 1 ..." (check-pairwise-gcd 1000))
+  true)
+
+(report-sb)

Task/Stern-Brocot-sequence/Clojure/stern-brocot-sequence-2.clj

@@ -0,0 +1,32 @@
+(ns test-p.core)
+(defn gcd
+  "(gcd a b) computes the greatest common divisor of a and b."
+  [a b]
+  (if (zero? b)
+    a
+    (recur b (mod a b))))
+
+(defn stern-brocat-next [p]
+  " p is the block of the sequence we are using to compute the next block
+    This routine computes the next block "
+  (into [] (concat (rest p) [(+ (first p) (second p))] [(second p)])))
+
+(defn seq-stern-brocat
+  ([] (seq-stern-brocat [1 1]))
+  ([p] (lazy-seq (cons (first p)
+                       (seq-stern-brocat (stern-brocat-next p))))))
+
+; First 15 elements
+(println (take 15 (seq-stern-brocat)))
+
+; Where numbers 1 to 10 first appear
+(doseq [n (concat (range 1 11) [100])]
+  (println "The first appearnce of" n "is at index" (some (fn [[i k]] (when (= k n) (inc i)))
+                 (map-indexed vector (seq-stern-brocat)))))
+
+;; Check that gcd between 1st 1000 consecutive elements equals 1
+;   Create cosecutive pairs of 1st 1000 elements
+(def one-thousand-pairs (take 1000 (partition 2 1 (seq-stern-brocat))))
+;   Check every pair has a gcd = 1
+(println (every? (fn [[ith ith-plus-1]] (= (gcd ith ith-plus-1) 1))
+               one-thousand-pairs))