# Project Euler Problem 42 For our 42nd problem in Project Euler, we need to find how many words have wordscores that are also triangle numbers. Triangle numbers are generated by the equation 1/2 * n * (n-1).

This problem was very similar to problem 22. However, since I learned about zipmap since then, I was able avoid using interleave this time. It would be difficult to imagine a shorter definition for letter-val or word-score.

def letter-val (zipmap "ABCDEFGHIJKLMNOPQRSTUVWXYZ" (range 1 27)))

(defn word-score [word] (reduce + (map letter-val word)))

(def triangle-nums (map #(* (/ 1 2) % (dec %)) (iterate inc 2)))

(defn triangular? [n] (= n (first (drop-while #(< % n) triangle-nums))))

(defn euler-42 [file]
(count (filter #(triangular? (word-score %)) (re-seq #"\w+" (rp file)))))

(euler-42 "/path/to/words.txt")

The obvious ugly part of this code is the definition of triangular. Though concise, it is a really terrible algorithm. An obvious enhancement I see for triangular? would be to push values into a map instead of the drop-while idiom. Actually, that might be a useful idiom to have, so let’s take a moment to write it (with help from stack overflow):

(defn make-lazy-predicate [coll]
(let [state        (atom {:mem #{} :unknown coll})
update-state (fn [{:keys [mem unknown] :as state} item]
(let [[just-checked remainder]
(split-with #(<= % item) unknown)]
(if (seq just-checked)
(-> state
(assoc :mem (apply conj mem just-checked))
(assoc :unknown remainder))
state)))]
(fn [item]
(get-in (if (< item (first (:unknown @state)))
@state
(swap! state update-state item))
[:mem item]))))

(def triangular-mapped? (make-lazy-predicate triangle-nums))

Spend some time studying that, it’s a nice bit of code that uses a closed-over atom to lazily memoize the infinite seq. Also, I learned about the existence of get-in through this function.

In the end, it’s probably simpler just to use the mathematical properties of triangular numbers:

(defn natural? [n] (= n (int n)))

(defn triangular-math? [n]
(let [m (Math/sqrt (+ 1 (* 8 n)))]
(and (> n 0) (natural? m))))

The performance of the lazy predicate version is actually only about 4 times slower than the mathematical definition in a simple benchmark, suggesting it might be a useful technique for lazy, ordered sequences whose mathematical properties aren’t well understood enough to analyze.

(dotimes [_ 5] (time (reduce + (filter triangular? (range 100000)))))
"Elapsed time: 2998.309655 msecs"
"Elapsed time: 2997.313831 msecs"
"Elapsed time: 2997.213703 msecs"
"Elapsed time: 2996.954904 msecs"
"Elapsed time: 3005.674668 msecs"

(dotimes [_ 5] (time (reduce + (filter triangular-math? (range 100000)))))
"Elapsed time: 16.292261 msecs"
"Elapsed time: 16.250659 msecs"
"Elapsed time: 16.274408 msecs"
"Elapsed time: 16.261641 msecs"
"Elapsed time: 16.327551 msecs"
nil

(dotimes [_ 5] (time (reduce + (filter triangular-mapped? (range 100000)))))
"Elapsed time: 109.244218 msecs"
"Elapsed time: 57.835461 msecs"
"Elapsed time: 57.654765 msecs"
"Elapsed time: 57.738389 msecs"
"Elapsed time: 57.532498 msecs"

Ciao for now!