(def ops (conj (re-seq #"." "+-*/") ""))

(defn gen-op-list [ops len]
  (if (= 1 len) (map vector ops)
    (for [op ops lst (gen-op-list ops (dec len))]
      (conj lst op))))

(defn compute 
  ([s] (compute [] [] + s))
  ([terms facs op s]
   (if-not (seq s) (apply + (conj terms (op (apply * facs))))
     (let [head (first s) sec (second s)
           curr-op (if (string? head)
                     (-> head read-string resolve))]
       (condp contains? head
         #{"*" "/"} (recur terms (conj facs (curr-op sec))
                           op (drop 2 s))
         #{"-" "+"} (recur (conj terms (op (apply * facs))) []
                           curr-op (rest s))
         (recur terms [head] op (rest s)))))))

(defn make-one [v]
  (Integer/parseInt (apply str v)))

(defn concat-numbers
  ([from] (concat-numbers [] [] from))
  ([to tmp from]
   (let [f (first from)]
     (cond
       (not (seq from)) (conj to (make-one tmp))
       (number? f) (recur to (conj tmp f) (rest from))
       :else (recur (conj to (make-one tmp) f) [] (rest from))))))

(def eq2012 (->> (rest (gen-op-list ops 9))
              (map #(conj % ""))
              (map (partial interleave (range 10 0 -1)))
              (map (partial remove #{""}))
              (map concat-numbers)
              (filter #(= (compute %) 2012))))

(println eq2012)