abcdef * m = fabcde solution

core.clj

(ns abcdef.core)

(set! *warn-on-reflection* true)
;(def a [:a :b :c :d :e :f])
;(def m :m)
;(def answer [:f :a :b :c :d :e])

(defn number-from-digits [digits]
  (let [digits-r (reverse digits)]
    (loop [digit 1 accumulator 0 left digits-r]
      (if (empty? left)
        accumulator
        (recur (* 10 digit)
               (+ accumulator
                  (* digit (first left)))
               (rest left))))))

(defn test-number [{:keys [a b c d e f]} m]
  (let [top (number-from-digits [a b c d e f])
        answer (number-from-digits [f a b c d e])]
    (= (* top m) answer)))

(defn digits-from-number [n]
  {:a (quot n 100000)
   :b (mod (quot n 10000) 10)
   :c (mod (quot n 1000) 10)
   :d (mod (quot n 100) 10)
   :e (mod (quot n 10) 10)
   :f (mod n 10)})

(defn run []
  (let [numbers (for [x (range 1 1000000) m (range 1 10)] [x m])]
    (loop [left numbers]
      (if-not (empty? left)
        (let [[x m] (first left)
              digits (digits-from-number x)]
          (if (test-number digits m)
            (println [digits {:m m}]))
          (recur (next left)))))))

;;;solution, all zeros ofc, and all the same numbers plus
;[{:a 0, :b 2, :c 5, :d 6, :e 4, :f 1} {:m 4}]
;[{:a 0, :b 5, :c 1, :d 2, :e 8, :f 2} {:m 4}]
;[{:a 0, :b 7, :c 6, :d 9, :e 2, :f 3} {:m 4}]
;[{:a 1, :b 0, :c 2, :d 5, :e 6, :f 4} {:m 4}]
;[{:a 1, :b 1, :c 1, :d 1, :e 1, :f 1} {:m 1}]
;[{:a 1, :b 2, :c 8, :d 2, :e 0, :f 5} {:m 4}]
;[{:a 1, :b 4, :c 2, :d 8, :e 5, :f 7} {:m 5}]
;[{:a 1, :b 5, :c 3, :d 8, :e 4, :f 6} {:m 4}]
;[{:a 1, :b 7, :c 9, :d 4, :e 8, :f 7} {:m 4}]
;[{:a 2, :b 0, :c 5, :d 1, :e 2, :f 8} {:m 4}]
;[{:a 2, :b 2, :c 2, :d 2, :e 2, :f 2} {:m 1}]
;[{:a 2, :b 3, :c 0, :d 7, :e 6, :f 9} {:m 4}]
;[{:a 3, :b 3, :c 3, :d 3, :e 3, :f 3} {:m 1}]
;[{:a 4, :b 4, :c 4, :d 4, :e 4, :f 4} {:m 1}]
;[{:a 5, :b 5, :c 5, :d 5, :e 5, :f 5} {:m 1}]
;[{:a 6, :b 6, :c 6, :d 6, :e 6, :f 6} {:m 1}]
;[{:a 7, :b 7, :c 7, :d 7, :e 7, :f 7} {:m 1}]
;[{:a 8, :b 8, :c 8, :d 8, :e 8, :f 8} {:m 1}]
;[{:a 9, :b 9, :c 9, :d 9, :e 9, :f 9} {:m 1}]