michalmarczyk

(def bt {:left {:value 3}
         :value 5
         :right {:left {:value 2}
                 :value :foo
                 :right {:left {:value :bar}
                         :value :quux
                         :right {:value 10}}}})

(loop [bt bt
       q (clojure.lang.PersistentQueue/EMPTY)]

michalmarczyk

(defn level-order [f tree]
  (loop [to-do [tree]]
    (if (empty? to-do)
      :done
      (do (dorun (map (comp f :value) to-do))
          (recur (mapcat (fn [{:keys [left right]}] (remove nil? [left right]))
                         to-do))))))

(level-order println
             {:value 1

michalmarczyk

user> (defn multi-comparator [& comps]
        (reify java.util.Comparator
          (compare [this x y]
            (reduce (fn [r ^java.util.Comparator c]
                      (if (zero? r) (.compare c x y) r))
                    0
                    comps))))
#'user/multi-comparator

;;; earlier versions, last-to-first

michalmarczyk

;;; how come the first version seems to be faster...?

(defn fact [n]
  (loop [n n r 1]
    (if (zero? n)
      r
      (recur (dec' n) (*' r n)))))

(defn ^:static fact ^long [^long n]
  (loop [n n r 1]

michalmarczyk

(defn gcd
  ([x y]
     (cond (zero? x) y
           (< y x)   (recur y x)
           :else     (recur x (rem y x))))
  ([x y & zs]
     (reduce gcd (gcd x y) zs)))

(defn lcm
  ([x y] (/ (* x y) (gcd x y)))

michalmarczyk

;;; implementation of Rob Lachlan's idea, see 
;;; http://stackoverflow.com/questions/3078811#3080868
(defn prime-Powers-LCM [m]
  (zipmap (primes m)
          (map (fn [p]
                 (->> (range)
                      (drop-while #(<= (expt p %) m))
                      first
                      dec))
               (primes m))))

michalmarczyk

;;; (set! *warn-on-reflection* true)
;;; for more spectacular results

(defn fact [n]
  (loop [n (long n) r 1]
    (if (zero? n)
    r
    (recur (num (dec n)) (* r n)))))

michalmarczyk

(defn munge [vs]
  (if (== 1 (count (first vs)))
    (reduce into vs)
    (let [gs (group-by #(% 0) vs)]
      (map (fn [k v]
             {:data k :children v})
           (keys gs)
           (->> (vals gs)
                (map (partial map #(subvec % 1)))
                (map munge))))))

michalmarczyk

(def CONS
  (fn [a b]
    (fn [x]
      (if (= x -1)
        'CONS
        (if (= x 0)
          a
          b)))))

(def FIRST

michalmarczyk

(defn merge-seqs
  "Merges sorted seqs of Comparable objects as in merge sort. Uses
  left-to-right precedence order among the input seqs when duplicates
  are present. Uses clojure.core/compare."
  ([xs ys]
     (lazy-seq
      (if (or (empty? xs) (empty? ys))
        (concat xs ys)
        (let [x (first xs)
              y (first ys)]