Project Euler Problem 32 asks us to once again find numbers that are pandigital from 1 to 9. This time, the digits of the numbers are taken from the equation (a*b=c), ignoring the * and = symbols.

;; Only two possible patterns of multiplications that produce 9 digits
;; 1. A 1 digit number times a 4 digit number can be 4 digits long.
;; 2. A 2 digit number times a 3 digit number can be 4 digits long. 

(defn as-digits [num]
  (map #(Character/getNumericValue %) (str num)))

(defn product-digits [a b]
  "Returns a list of digits of a, b, and (* a b)."
  (lazy-cat (as-digits a) (as-digits b) (as-digits (* a b))))

(defn all-unique? [digits]
  (let [unique (distinct digits)]
    (= (count unique) (count digits))))

(defn pandigital-9? [digits]
  (and (nil? (some zero? digits))
       (= 9 (count digits))
       (all-unique? digits)))

(defn euler-32 []
  (reduce + (into #{} (concat
                       (for [a (range 1 10)
                             b (range 1000 10000)
                             :when (pandigital-9? (product-digits a b))]
                         (* a b))
                       (for [a (range 10 100)
                             b (range a 1000)
                             :when (pandigital-9? (product-digits a b))]
                         (* a b))))))

(euler-32)

With a bit of effort, I was able to shorten this definition into the much more succinct one that follows:

(defn pandigital-multiplication? [a b]
  (= "123456789" (apply str (sort (flatten (map as-digits [a b (* a b)]))))))

(defn euler-32-concise []
  (reduce + (distinct (for [a (range 2 5000)
                            b (range a (/ 9999 a))
                            :when (pandigital-multiplication? a b)]
                        (* a b)))))

(time (euler-32-concise)) ;; "Elapsed time: 3415.286711 msecs"

Yet again, the folks over at clojure-euler have even more performant solutions, but what was most surprising to me is how changing the definition of pandigital-multiplication? could speed up my code by 10x:

;; Using split (thanks, semmons99!)
(defn pandigital-multiplication? [a b]
  (= "123456789" (apply str (sort (rest (.split (str a b (* a b)) ""))))))

(time (euler-32-concise)) ;; "Elapsed time: 161.618939 msecs"

Try as a might to modify it, I couldn’t get the algorithmically superior approach posted on clojure-euler by bibi (which uses combinations and permutations from clojure.contrib.combinatorics) to go faster than the above code. I guess the overhead of creating the combinations and permutations exceeds the benefit obtained through the reduction in the number of required tests for pandigitality.