Problem 28 asks us to find the sums of the diagonals in a square matrix of numbers created by spiraling outward from the number 1 in a clockwise direction.

My first attempt was a little clunky because I named too many things:

```
(defn diagonals [start space]
(take 4 (drop 1 (take-nth space (range start (+ start (* 5 space)))))))
(defn euler-28 [spiral]
(loop [sum 1
start 1
by 2]
(let [ds (diagonals start by)]
(if (>= start (* spiral spiral))
sum
(recur (+ sum (reduce + ds)) (last ds) (+ 2 by))))))
(euler-28 1001)
```

However, a little thought and I realized I could simplify this a little without too much ugliness:

```
(defn euler-28-revised [n]
"Compute the sum of the diagonals in an n by n clockwise spiral. "
(assert (and (> n 0) (odd? n))) ;; Must be odd to have diagonals!
(let [diags (fn [m] (take 4 (iterate #(- % (dec m)) (* m m))))
squares (take-while #(> % 1) (iterate #(- % 2) n))]
(reduce + (flatten [(map diags squares) 1]))))
(euler-28-revised 1001)
```

Maybe that code is a bit dense, but it doesn’t have any recursion, which means it should be safe for the stack even for very big spirals. If `flatten`

is incremental, it probably is safe for the heap as well and could be used to compute really really big spirals. Let’s check if `flatten`

is incremental and lazy:

```
user> (take 6 (flatten (partition 2 1 (range))))
(0 1 1 2 2 3)
```

Since `flatten`

is working lazily, I am going to guess that when combined with `reduce`

in the above, only a very small number of elements are held in memory here and this will not damage the heap even with a gajillion elements.

I added the `assert`

just to prevent myself from accidentally giving the function meaningless input values, but I’ve seen very little clojure code that uses `assert`

yet so I’m not sure of the proper idiom for using it.