# Learning Clojure with Project Euler

This article is a quick introduction to Clojure from someone still learning the language. I work through a few Project Euler problems, refining solutions along the way. In the end I give some general impressions of the language, the install and setup process, and support for Clojure within different development tools. Long time readers of this blog will remember I also used Project Euler to learn Scala basics a while ago.

I haven’t done much with Scala since then, mostly because I found the syntax a bit too quirky and the documentation lacking. Lau Jensens’s comparisions between Scala and Clojure inspired me to have a look at Clojure.

When getting started with a new language, I like to use a site that has excercises for programming practice. A great site for this is Project Euler; it gives you short problems to solve, and once a problem is correctly solved you are given access to the forum for that problem which contains hundreds of solutions written in different languages. Each of the problems are designed to be solved by some combination of mathematical insight and computer programming. Enough talk; lets see some code.

**Warning: **Spoilers ahead for Project Euler problems 1 through 3.

## Project Euler Problem 1

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Find the sum of all the multiples of 3 or 5 below 1000.

Here is the code I came up with:

```
(defn e1 [limit]
(reduce + (filter #(or (zero? (mod % 3))
(zero? (mod % 5)))
(take (- limit 1) (iterate inc 1)))))
(e1 1000)
```

We start out by defining the function `e1`

which takes a `limit`

. The `limit`

is the stopping point of the the function. Since we want the sum of all multiples below 1000, on line 5 we call `e1`

with 1000 for our `limit`

. Starting at the bottom of `e1`

, this code creates a lazy sequence of integers by starting at one and incrementing `(inc)`

from there. The `take`

just outside of that grabs the first limit – 1 elements from the sequence.

Now we want to `filter`

the sequence so that it only contains integers that are multiples of 3 or 5. The first argument to `filter`

is an anonymous function (lambda in Common Lisp) and the second argument is the sequence we just created. Clojure uses `#(...)`

as syntactic sugar for an anonymous function. Looking at that function on lines 2 and 3, the `%`

has nothing to do with the modulus. Each element of the sequence is being bound to `%`

when it is passed into the modulus function.

So now that we have our sequence, we want to add up everything inside to get the answer. `reduce`

applies the + function to each element in the sequence, plus the total so far, and we’re done!

Unfortunately, the solution board on Project Euler doesn’t have any Clojure solutions, but DZone has a wiki of Clojure solutions. Comparing my solution with some of the others there, it is looking like pretty idiomatic Clojure code. However, using the `range`

function, line 4 can be simplified to `(range 1 limit)`

, which simply creates a lazy sequence of all of the numbers between 1 (inclusive) and `limit`

(exclusive).

## Project Euler Problem 2

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, …

Find the sum of all the even-valued terms in the sequence which do not exceed four million.

Lets start out by defining the sequence of Fibonacci numbers:

```
(def fibs (lazy-cat [0 1]
(map + fibs (rest fibs))))
```

On line 2 we describe `fibs`

as a sequence created by adding each element of `fibs`

to each element of “the rest of fibs”. The rest of fibs is just everything but the first element, or for those familiar with Common Lisp, we are taking the tail. On line 1 we seed the sequence with 0 and 1.

Now that we have the sequence we sum up the evens under 4 million:

```
(defn e2 [limit]
(reduce + (filter #(zero? (mod % 2))
(take-while #(< % limit) fibs))))
```

This is just a simple `filter`

like problem 1.

Now, do we really need to create a separate `fibs`

function? Why not combine the two functions? We can’t use an anonymous function for the argument to `filter`

, because we want to be able to define `fibs`

in terms of itself. What about this:

```
(defn e2 [limit]
(let [fibs2 (lazy-cat [0 1]
(map + fibs2 (rest fibs2)))]
(reduce + (filter #(zero? (mod % 2))
(take-while #(< % limit) fibs2)))))
```

OK that was a trick. It seems to me that this should work, but let doesn’t allow lazy evaluation; it gives an error that `fibs2`

isn’t defined when we try to use it in the `map`

.

## Project Euler Problem 3

The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

To tackle this one, lets write a recursive function that takes a number to factor (`num`

) and also the lowest prime that could be a factor of that number (`cur`

). As we recurse, if `cur`

is a factor, then we call `factor`

again with `cur / factor`

, and continue looking for factors. If we haven’t found a factor, then lets check if `cur + 1`

is a factor. Because we continue dividing factors out of `cur`

and we are looking at factors from lowest to highest, we know that if `cur`

and `num`

are ever equal we’ve found the largest factor, which must also be prime.

```
(defn factor [num cur]
(if (= num cur)
num
(if (zero? (mod num cur))
(factor (/ num cur) cur)
(factor num (inc cur)))))
(factor 600851475143 2)
```

So, lets start with the base case on line 2. To stop the recursion, we return `num`

when `cur`

and `num`

have the same value. Otherwise (line 4) we want to continue looking for factors. If we have a factor, then recursively look for factors of `num / cur`

. If we don’t have a factor (line 6), then increment `cur`

and continue looking for factors. When we call `factor`

, we need to figure out the lowest prime that could be a factor. By inspection, we can see that 2 isn’t a factor of 600851475143, but 2 works as the starting value of `cur`

.

## First Impressions of Clojure

Clojure’s syntax is very clean, and just makes sense. There isn’t much syntax to learn, just parentheses and the odd `#`

or `%`

. Although I didn’t use it here, there is some additional syntax to learn for creating vectors, maps, and sets, but its easy to learn. People who haven’t used Lisp in the past may run into a bit more trouble, but I suspect that anyone who has done functional programming before will pick up Clojure quickly.

The API does a good job of documenting everything, and the Clojure site in general is well organized. The only suggestion I have for improvement here is to include a page describing the more common language features and gotchas, along with some examples. Ruby does this pretty well. Anyone looking for a more structured introduction to Clojure may want to pick up the Programming Clojure book from The Pragmatic Programmers.

I found tool support to be lacking, which maybe is to be expected since Clojure isn’t a very popular language. There are two emacs modes for Clojure; one barfed out an error on me, and the other doesn’t seem to be picking up all of the keywords, function names, and other syntax bits that should be colorized. It also wasn’t supported by GeSHi, which I use for syntax highlighting here on GrokCode. I put together a new GeSHi language file for Clojure, and sent it to the project owner for inclusion. Meanwhile, you can get the Clojure file here. Rename it with a php extension and drop it into the geshi directory.

As a whole, I was impressed with Clojure, and plan to continue working with it.