Language minutiae and learning to SWIM

Further to Enlightenment in action, here's a tiny bit more light that I discovered on my journey up to Newcastle this morning.

I solved 4Clojure puzzle 100 (Least Common Multiple) with this code:

(fn [& args]
  (let [[x & xs] (reverse (sort args))
        are-divisors? (fn [n] (zero? (reduce #(+ %1 (mod n %2)) 0 xs)))]
    (->> (iterate (partial + x) x)
         (filter are-divisors?)
         first)))

I'm not a mathematician, so forgive me, but my approach to the solution was to take the largest of the numbers supplied, and build a lazy sequence of its multiples, (e.g. starting with 7 it would be 7, 14, 21, 28 etc). The first number in that sequence that had the rest of the numbers as factors was the answer.

Expressing that in Clojure, I first marshalled the input and prepared a function that I could use in the main part of the resolution. In the let binding, I split the input numbers into a single scalar - the greatest of them - and a sequence of the rest of them. Then I defined a function on the fly to close over that "rest" sequence (represented by the xs var) and determined whether those numbers were divisors of a given number n.

Looking in detail at this function, here's what I was expressing:

  • fold over the list of numbers: (reduce ... 0 xs)
  • in each case, calculate the modulo of n divided by that number
  • by wrapping this in a reduce, add up the total of the modulo results: #(+ %1 (mod n %2))
  • look to see if the total was zero, which would represent the fact that all the numbers were indeed divisors: (zero? ...)

Neat enough, I thought.

But the nature of this is slightly mechanical ... I wanted to know whether every number was a divisor, and did that with maths (deriving a modulo total and checking for zero). So while I was doing well, I didn't entirely Say What I Mean (SWIM).

Looking at someone else's solution, I discovered the predicate function every? that was perfect, and would allow me to SWIM better.

Here's my definition:

(fn [n] (zero? (reduce #(+ %1 (mod n %2)) 0 xs)))

and here's a version using every?:

(fn [n] (every? #(zero? (mod n %)) xs))

Yes, it's shorter, which is nice, but the difference is striking. With this version, I'm now saying: "is every modulo of n, and the numbers under test, zero?"

One small step closer to a more natural ability to Say What I Mean.