More pandigital problem madness for problem 43. Honestly, I think the guys at Project Euler were running out of ideas or something.

Coming up with a concise but inefficient solution was straightforward:

(use '[clojure.contrib.combinatorics :only (permutations)])

(defn as-int [coll]  (Integer/parseInt (apply str coll)))

(defn special? [n]
  (every? true? (map #(zero? (rem %1 %2))
                     (map as-int (partition 3 1 (rest n)))
                     [2 3 5 7 11 13 17])))

(defn euler-43 []
  (reduce + (map #(BigInteger. (apply str %))
                 (filter special? (permutations "0123456789")))))

(time (euler-43)) ;; "Elapsed time: 29441.089387 msecs"

The speed of the above algorithm could be greatly improved by not computing permutations whose first several digits do not satisfy the particular special? property for which we are testing. This means we could use nth-permutation from problem 24, and check how many digits are matching sequentially. Then we can skip ahead as needed until we find a match.

(defn factorial [n]
  (reduce * (range 2 (inc n))))

(defn all-but-nth [coll n]
  (lazy-cat (take n coll) (drop (inc n) coll)))

(defn nth-permutation [coll n]
  (if (= 1 (count coll))
    [(nth coll 0)]
    (let [f (factorial (dec (count coll)))
          x (quot n f)]
      (concat [(nth coll x)]
              (nth-permutation (all-but-nth coll x)
                               (- n (* x f)))))))

(defn as-bigint [coll] (BigInteger. (apply str coll)))

(defn matched-digits [n]
  (let [s (map #(zero? (rem %1 %2))
               (map as-bigint (partition 3 1 (rest n)))
               [2 3 5 7 11 13 17])
        c (count (take-while true? s))]
    (+ c 3)))

(defn euler-43-fast []
  (let [digits "0123456789"
        len (count digits)
        max (factorial len)]
    (loop [n 0
           ret 0]
      (if (>= n max)
        ret
        (let [p (nth-permutation digits n)
              m (matched-digits p)]
          (if (= m len)
            (recur (inc n) (+ ret (as-bigint p)))
            (recur (+ n (factorial (dec (- len m)))) ret))))))) 

(time (euler-43-fast)) ;; "Elapsed time: 4368.852353 msecs"

That was my best independent effort, without referencing another site. Yet, when I looked on clojure-euler I was surprised to an interesting solution by kotarak that completes in 15 msecs! By packaging all the computation into one hairy nut of a macro, the problem definition itself becomes quite clear. I must confess that the exact operation of his macro remains mysterious to me, however.