Manual merge of working branch

rebcabin · rebcabin · commit be7d3bbe880b · 2013-07-29T18:13:13.000-07:00
diff --git a/for-clojure/problem-106/src/problem_106/core.clj b/for-clojure/problem-106/src/problem_106/core.clj
@@ -12,27 +12,27 @@
          (println "----------------")
          x#)))
 
-;;;  ___         _    _             _  __   __ 
-;;; | _ \_ _ ___| |__| |___ _ __   / |/  \ / / 
+;;;  ___         _    _             _  __   __
+;;; | _ \_ _ ___| |__| |___ _ __   / |/  \ / /
 ;;; |  _/ '_/ _ \ '_ \ / -_) '  \  | | () / _ \
 ;;; |_| |_| \___/_.__/_\___|_|_|_| |_|\__/\___/
-                                           
+
 
 (def __ (letfn [(d [n] (* n 2)) ; double
                 (h [n] (/ n 2)) ; halve
                 (a [n] (+ n 2)) ; add
                 (hop-count [n t m hops-so-far]
                   (cond
                    (= n t)            hops-so-far ; end search
-                   (>= hops-so-far m) hops-so-far ; limit depth 
+                   (>= hops-so-far m) hops-so-far ; limit depth
                    :else
                    (let [nh (inc hops-so-far) ; take a hop
                          dh (hop-count (d n) t m nh)
                          ah (hop-count (a n) t m nh)
                          hh (when (even? n) (hop-count (h n) t m nh))]
                      (cond
                       (odd? n)  (min dh ah)
-                      (even? n) (min dh ah hh)))))] 
+                      (even? n) (min dh ah hh)))))]
           (fn [s t] (hop-count s t 10 1))))
 
 (def __ #((fn r [n s]
@@ -48,7 +48,7 @@
                   (cond
                    (ts n)      hops ; end search
                    :else
-                   (hop-count n (set (concat ts (map d ts) (map a ts) (map h ts))) (inc hops))))] 
+                   (hop-count n (set (concat ts (map d ts) (map a ts) (map h ts))) (inc hops))))]
           (fn [s t] (hop-count t #{s} 1))))
 
 (println (map #(apply __ %) [[1 1] [3 12] [12 3] [5 9] [9 2] [9 12]]))
@@ -59,39 +59,8 @@
 (take 5 (range 5 java.lang.Integer/MAX_VALUE 2))
 (for [cand [2 3 4]] cand)
 (every? even? [4 2])
-
-(def zork
-  (fn [n] (take n (letfn [(primes []
-                           (lazy-seq
-                            (concat
-                             [2 3]
-                             (for [cand (range 5 java.lang.Integer/MAX_VALUE 2)
-                                   :when (every? (fn [p] (not= 0 (mod cand p)))
-                                                 (take-while
-                                                  (fn [p] (< (* p p) cand))
-                                                  (primes)))
-                                   ]
-                               cand
-                               ))))]
-                   (primes)
-                   ))))
-
-(def zork
-  (fn [n] (take n (letfn [(primes []
-                           (lazy-seq
-                            (concat
-                             [2 3]
-                             (for [cand (range 5 java.lang.Integer/MAX_VALUE 2)
-                                   :when (every? (fn [p] (not= 0 (mod cand p)))
-                                                 (take-while
-                                                  (fn [p] (< (* p p) cand))
-                                                  (primes)))
-                                   ]
-                               cand
-                               ))))]
-                   (primes)
-                   ))))
-
+(range 5 100 2)
+(take 15 (iterate inc 2))
 
 (def driver-table
   (pdump (map (partial zipmap [:chan :pl :driver-name :asin :prime :amount])
@@ -143,8 +112,8 @@
 (pdump (allocate (first pnls)
                  (driver-spec :prod-cogs (first pnls))))
 (defn fact [n acc]
-  (if 
-    (< n 2N) 
+  (if
+    (< n 2N)
     acc
     (recur (dec n) (* acc n))))
 
@@ -160,12 +129,32 @@
                                 primes
                                 ))
                             [2 3]
-                            (range 5N (fact 1000N 2)))
+                            (range 5N 1000N 2))
                     )))
 
-;; primes = [2, 3] ++ [ cand | cand <- [5, 7..], 
+((fn [comb & hms]
+   (reduce
+    (fn [dest src]
+      (into dest
+            (reduce
+             (fn [hm [k v]]
+               (assoc hm k
+                      (let [curr (dest k)]
+                        (if curr (comb curr v) v))))
+             {}
+             src)))
+    hms))
+ *
+ {:a 2, :b 3, :c 4},
+ {:a 2},
+ {:b 2},
+ {:c 5}
+ )
+
+((fn [sent])
+ "Have a nice day.")
+
+;; primes = [2, 3] ++ [ cand | cand <- [5, 7..],
 ;;                             all (\p -> notDvbl cand p)
 ;;                                 (takeWhile (\p -> p*p < cand) primes) ]
 
-(defn -main [& args]
-  (alter-var-root #'*read-eval* (constantly false)))
