# Project Euler in Clojure – Problem 11

This is my solution to Problem 11 of Project Euler. As always, my progress you can tracked on GitHub at https://github.com/stevenproctor/project-euler-clojure.

Problem 11 of Project Euler is described as:

```        08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

What is the greatest product of four adjacent numbers in any
direction (up, down, left, right, or diagonally) in the 2020 grid?
```

I looked into using Incanter but didn’t get it setup as I am using Clojure 1.4, and had some issues getting the dependencies resolved. No big deal though, as I just used a vector of vectors to represent a matrix. I created a new file matrix.clj, which got the namespace definition for project-euler.matrix.

```(ns project-euler.matrix)
```

The first function I defined was `transpose`, since I am going to want to work against the columns, but rows are easier to think about and work with.

```(defn transpose [m]
(vec (apply map vector m)))
```

Since I am going to need to find groups of four numbers in the matrix, I defined the following to functions to get all possible groups of four in the rows, and in the columns.

```(defn partition-rows [m n step]
(if (= (count m) 0)
[]
(concat (partition n step (first m)) (partition-rows (rest m) n step))))

(defn partition-columns [m n step]
(partition-rows (transpose m) n step))
```

The `partition-rows` function just concats the results of calling partition on each row with the group size, `n`, and the step, by calling partition on the first row of the matrix `(first m)`, and then calling `partition-rows` again with the remaining rows in the matrix given `(rest m)`. The function `partition-columns` simply transposes the matrix `m` and then calls `partition-rows` with that matrix.

The next two functions are two helper functions, which were defined after writing some of the following functions, and exist to better express intent.

```(defn matrix-get [m r c]
(nth (nth m r) c))

(defn row [m n]
(nth m n))
```

The function `matrix-get` gets the `r`th row from the matrix `m` and then gets the `c`th item in that row. The function `row` gets the row for a matrix. Again nothing special about these functions except that they help to communicate the intent, and give the concept a name. These were littered around the code so the functions were created as part of tidying up. In looking at it as I was writing up this post, I realized I still didn’t pull out the concept of row in the function `matrix-get`, and the two functions should probably be defined as follows instead:

```(defn row [m n]
(nth m n))

(defn matrix-get [m r c]
(nth (row m r) c))
```

Working through getting the diagonals, I posted a call for help about a clean way to get the diagonals for a matrix in the post Smelly matrix diagonals. I got some good comments, and after taking a bit to pick apart the functions, I went with the following from the comments, thanks to Mark.

```(defn diagonals [m]
(let [rdim (count m)
cdim (count (first m))]
(->> (for [r (range rdim), c (range cdim)]
{(+ r (- cdim c)) [(matrix-get m r c)]})
(apply merge-with into)
vals)))
```

This worked great, but I also needed to get the diagonals going from the bottom left to the top right, which resulted in the function `reverse-diagonals`.

```(defn reverse-diagonals [m]
(let [rdim (count m)
cdim (count (first m))]
(->> (for [r (range rdim), c (range cdim)]
{(+ r c) [(matrix-get m r c)]})
(apply merge-with into)
vals)))

```

As this was almost the same function as diagonals, with just a different function for getting the key, so I extracted a function `matrix-lines` which resulted in:

```(defn matrix-lines [m f]
(let [rdim (count m)
cdim (count (first m))]
(->> (for [r (range rdim), c (range cdim)]
{(f rdim cdim r c) [(matrix-get m r c)]})
(apply merge-with into)
vals)))

(defn diagonals [m]
(matrix-lines m (fn [rdim cdim r c] (+ r (- cdim c)))))

(defn reverse-diagonals [m]
(matrix-lines m (fn [rdim cdim r c] (+ r c))))
```

Where the function `matrix-lines` will generate the lines based off of a function to generate a key for a given cell.

I have seen that it is idiomatic Clojure code to use `_`s to signify function variables that are not used, so looking at this with some fresh eyes, should those variables defined in the functions `diagonals` and `reverse-diagonals` be an `_` instead, even though they are the first bindings to the function?

The last part of working with the matrix that I needed were functions to partition the diagonals, and get all the partitioned diagonals in both directions.

```(defn partition-diagonals [m n diagonals-fn]
(apply concat (map #(partition n 1 %) (diagonals-fn m))))

(defn partition-every-diagonal [m n]
(concat (partition-diagonals m n diagonals) (partition-diagonals m n reverse-diagonals)))
```

The function `partition-diagonals` returns the result of `concat`ing every resulting seq from calling `partition` on every result of call the `diagonals-fn` which is the function to get the diagonals that was passed in as the second parameter. The function `partition-every-diagonal` simply `concat`s the results of calling `partition-diagonals` with the functions `diagonals` and `reverse-diagonals`.

```(defn problem11
[]
(let [m [[ 8  2 22 97 38 15  0 40  0 75  4  5  7 78 52 12 50 77 91  8]
[49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48  4 56 62  0]
[81 49 31 73 55 79 14 29 93 71 40 67 53 88 30  3 49 13 36 65]
[52 70 95 23  4 60 11 42 69 24 68 56  1 32 56 71 37  2 36 91]
[22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80]
[24 47 32 60 99  3 45  2 44 75 33 53 78 36 84 20 35 17 12 50]
[32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70]
[67 26 20 68  2 62 12 20 95 63 94 39 63  8 4  91 66 49 94 21]
[24 55 58  5 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72]
[21 36 23  9 75  0 76 44 20 45 35 14  0 61 33 97 34 31 33 95]
[78 17 53 28 22 75 31 67 15 94  3 80  4 62 16 14  9 53 56 92]
[16 39  5 42 96 35 31 47 55 58 88 24  0 17 54 24 36 29 85 57]
[86 56  0 48 35 71 89  7  5 44 44 37 44 60 21 58 51 54 17 58]
[19 80 81 68  5 94 47 69 28 73 92 13 86 52 17 77  4 89 55 40]
[ 4 52  8 83 97 35 99 16  7 97 57 32 16 26 26 79 33 27 98 66]
[88 36 68 87 57 62 20 72  3 46 33 67 46 55 12 32 63 93 53 69]
[ 4 42 16 73 38 25 39 11 24 94 72 18  8 46 29 32 40 62 76 36]
[20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74  4 36 16]
[20 73 35 29 78 31 90  1 74 31 49 71 48 86 81 16 23 57  5 54]
[ 1 70 54 71 83 51 54 69 16 92 33 48 61 43 52  1 89 19 67 48]]]
(apply max
(map multiply
(concat (partition-rows m 4 1)
(partition-columns m 4 1)
(partition-every-diagonal m 4))))))
```

The function `problem11` applys the function `max` to the result of calling `multiply` on every possible partition of the matrix m, to get largest multiple of ‘four adjacent numbers in any direction’.

So far, this has been the Project Euler problem with the most code that was needed to solve the problem, including the ones I have solved but not posted answers to yet. While overall this is still not a great deal of code, I am wondering if there are any things that I am missing that might make this even more concise and expressive.

Is there anything that I have missed? Anything interesting in my approach? Again, I thank you in advance for any comments that you might have on this.

Thanks again,
–Proctor

# Project Euler in Clojure – Problem 10

This is my solution to Problem 10 of Project Euler. As always, my progress you can tracked on GitHub at https://github.com/stevenproctor/project-euler-clojure.

Problem 10 of Project Euler is described as:

`Find the sum of all the primes below two million.`

And my solution for this, including previously defined functions created as part of solving the previous problems, is the following:

```(defn square [n]
(* n n))

(defn sum [s]
(reduce + s))

(defn primes-under2 [n]
(let [sieve (transient (set (cons 2 (range 3 n 2))))]
(loop[s sieve
f 3]
(cond (> (square f) n) (persistent! s)
:else (recur (reduce disj! s (range (square f) n f)) (inc f))))))

(defn problem10
([] (problem10 2000000))
([n] (bigint (sum (primes-under2 n)))))
```

The functions sum and square came from the suggestion of Arcane Sentiment in a comment on a previous problem, as well as a post of his Square in R7RS.

The function primes-under2, is my second attempt at creating the primes under a given number using the Sieve of Eratosthenes. The short description is that the function uses sets of multiples of each integral number up to the square root of the number specifies and removes those items from the set. A more detailed write up can be found in my post Sieve of Eratosthenes in Clojure using Sets.

With those functions defined, I simply get the sum of the call to primes-under2 and make it a bigint to try to ensure the sum will be handled nicely for large numbers, but looking at it now, it is probably not even needed.

**Update**
I have posted my solution to Problem 11.

–Proctor

# Project Euler in Clojure – Problem 9 Redux

After contemplating on the comments on my previous solution to Problem 9 of Project Euler, I took a few minutes and looked into the for comprehension and then rewrote the method for generating the pythagorean triples.

I also had a comment pointing out that I was missing some triples generated, and that I was likely lucky in getting a triple that matched the criteria. When I was originally looking at wikipedia at the posting on Pythagorean Triple, I saw the following text:

```Despite generating all primitive triples, Euclid's formula does not produce all triples.
```

I figured I was good with just generating all primitive triples, but as it was pointed out that I was missing some, I added in the functionality to generate the multiples of the triples as well.

The function pythagorean-triples has now been rewritten as:

```(defn pythagorean-triples []
(for [m (range 2 500)
n (range 1 m)
k (range 1 500)]
(map (partial * k) (pythagorean-triple-for m n))))
```

Thanks for the feedback, and this is much nicer, even with the extra computation for multiplying the triples by a K.

–Proctor

# Project Euler in Clojure – Problem 9

This is my solution to Problem 9 of Project Euler. If you would like to track my progress you can follow my repository on github.com to keep track of my progress, which can be found at https://github.com/stevenproctor/project-euler-clojure.  Here is my solution to Problem 8.

Problem 9 of Project Euler is described as:

```There exists exactly one Pythagorean triplet for which a + b + c = 1000.
Find the product abc.```
```(defn pythagorean-triple-for [m n]
(let [mm (Math/pow m 2)
nn (Math/pow n 2)]
(sort [(int (- mm nn)) (* 2 m n) (int (+ mm nn))])))

(defn pythagorean-triples
([] (cons (pythagorean-triple-for 2 1) (pythagorean-triples 2 2)))
([m n]
(if (< n m)
(lazy-seq (cons (pythagorean-triple-for m n) (pythagorean-triples m (inc n))))
(recur (inc m) 1))))

(defn problem9 []
(multiply (first (filter #(= (sum %) 1000) (pythagorean-triples)))))
```

The function pythagorean-triple-for generates the Pythagorean Triple which corresponds to any pair of digits (m n) where n < m. The Pythagorean Triple for (2 1) is the triple [3 4 5], and for (32 21) results in [53 1344 1465].

The function pythagorean-triples creates a lazy sequence of triples by generating triples starting with m = 2 and n = 1, by incrementing n until m = n, and then increments m, and continues for all values of n from 1 to m. Resulting in calls to pythagorean-triple-for against the following pairs ([2 1] [3 1] [3 2] [4 1] [4 2] [4 3] …).

The function problem9 then finds the first where the sum of the triple is equal to 1000, and takes the multiple of that result. This was solved before Arcane Sentiment posted his comment about the helper functions for sum and multiply. After cleaning up the previously code to use those, the code then became the following.

```(defn problem9 []
(multiply (first (filter #(= (sum %) 1000) (pythagorean-triples)))))
```

Having played a bit more with Clojure since I solved this, the function pythagorean-triples seems like it could be nicer. The mix of recur, and the recursive function call seem kinda smelly, and looking at the solution again, I am now wondering if there is a use of map or reduce which might clean this up. Any thoughts?

**Update**
Thanks to the comments I have updated the function pythagorean-triples, and posted the changes in the post Problem 9 Redux.

–Proctor

# Project Euler in Clojure – Problem 8

This is my solution to Problem 8 of Project Euler. If you would like to track my progress you can follow my repository on github.com to keep track of my progress, which can be found at https://github.com/stevenproctor/project-euler-clojure.  Here is my solution to Problem 7.

Problem 8 of Project Euler is described as:

```Find the greatest product of five consecutive digits in the 1000-digit number.
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
```
```
(defn digits-of [n]
(map #(Integer/parseInt (str %)) (str n)))

(defn problem8 []
(let [n 7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450]
(apply max (map
#(apply * %) (partition 5 1 (digits-of n))))))
```

The digits-of function takes a number and creates a sequence of the digits of the number, in the same way a string can be treated as a sequence of characters. I then call partition on that stream of digits to get the digits in groups of five. Those groups of five get multiplied together, and we find the max of those results.

Again, I would love comments and suggestions on my solution to this problem, and if there are tweaks to make it more Clojure-ish.

**Update**
I have posted my solution to Problem 9.

–Proctor

# Smelly matrix diagonals

As I am working on Problem 11 in Project Euler, I am trying to use a matrix and some functions against that matrix to help me solve the problem. I spent a bit of time browsing incanter and its documentation, but did not see anything that would give me what I was looking for.

The particularly nasty function I am encountering is finding all of the diagonals in a matrix. Given a matrix of

``` 1  2  3  4
5  6  7  8
9 10 11 12
13 14 15 16
```

I am would expect the following sequence of vectors:

```[1 6 11 16] [2 7 12] [3 8] [4] [5 10 15] [9 14] [13]
```

Where I think the nasty-ness is coming from is that function is seeming very imperative, and it seems like there should be a much more elegant solution to this, but I am currently not seeing it. In addition to what seems to be a large smell in the code, what makes me think I am doing something “wrong” for Clojure is having seen the elegant solution to Conway’s Game of Life in Programming Clojure which can be found at Github. In the book they take an imperative implementation from another language into Clojure, and then they show a functional solution which turns the imperative version on its head and spins it like a top.

Here is what I came up with, and I can only assume that others would think there is a large smell to this as well.

```(defn diagonals [m]
(let [rdim (count m)
cdim (count (first m))]
(loop [diags []
roff 0
coff 0]
(cond (>= coff cdim) (recur diags (inc roff) 0)
(>= roff rdim) diags
:else (recur
(concat diags
(conj []
(for [i (range 0 (min (- rdim roff) (- cdim coff)))]
(matrix-get m (+ roff i) (+ coff i)))))
roff
(if (zero? roff) (inc coff) cdim))))))
```

Even as I was writing this function, I could tell that it is doing way to much work in it, and that it is not very composable, nor does it seem to take advantage of much composability. As a side note, one of the things that was also a large sign that I was doing something “wrong” for Clojure, was that it was difficult to incrementally develop, modify, and debug in the REPL.

I would love some suggestions on how to give this code a good scrubbing, and clean up this function.

–Proctor

# Sieve of Eratosthenes in Clojure using sets

Working through the Project Euler problems, and with the comment from Arcane Sentiment about filtering based off of a set of primes, I was trying to program the Sieve of Eratosthenes. I also realized that the Sieve becomes a set based problem, so I went about trying to solve it using sets.

My first approach was simply using the difference function given in clojure.set.

```(defn primes-under [n]
(loop [sieve (set (cons 2 (range 3 n 2)))
f 3]
(if (> (square f) n)
sieve
(recur (difference sieve (range (square f) n f)) (inc f)))))
```

I start with the set of numbers starting by cons-ing 2 onto the range from 3 to n, skiping every other number, to get the odd numbers up to n.

The new sieve becomes the the difference between the current sieve, and the multiples of the factor f. I use (range (square f) n f) as a subset of the factors of f up to the number n. I start the range at the square of the factor, as any multiples below the square of the factor would already have been sieved out from the factors below it. So for multiples of 5, I can ignore (10, 15, 20) as they are multiples of 2 and 3, the other primes below 5, and as a result I only need to get multiples of 5 starting at 25.

When timing this solution by using:

```(time (dorun (primes-under 1000000)))
```

The timing for the primes under 1,000,000 is around 2.1 seconds, and anywhere from 6 to 10 seconds for the primes under 2,000,000.

I wasn’t happy with this performance, especially after seeing Christophe Grand’s solution and timing on his blog post Everybody loves the Sieve of Eratosthenes.

I decided to try my hand at solving this using a transient set. After many missteps in using a transient set, due to not having used them before, I came up with the following solution:

```(defn primes-under2 [n]
(let [sieve (transient (set (cons 2 (range 3 n 2))))]
(loop [s sieve
f 3]
(cond (> (square f) n) (persistent! s)
:else (recur (reduce disj! s (range (square f) n f)) (inc f))))))
```

I define sieve as a transient set, and instead of using difference, I call reduce on the sieve using the function disj! for the ranges of numbers to filter out. I need to use disj! to remove that number from the sieve, as this is now a transient set I am working against.

The timing of this solution is now down to 1.1 seconds for primes under 1,000,000, and primarily in the 3 second range for the primes under 2,000,000.

I am still not quite satisfied with this solution, and would love suggestions as to how to avoid those numbers which have been filtered out of the sieve already.  As I just do a (inc f), I would still get the numbers 4, 6, 8, 9, 25, etc, that are multiples of other primes, but I could not figure out how to skip these numbers.  I tried the functions contains?, get, superset?, subset?, difference, but these were not giving me the result when dealing with the transient set.

If someone could tell me if I have missed anything I should try for filtering out non-prime numbers as factors, I would love to get your suggestions to try it out, and I will post a follow up with the results.

–Proctor

# Project Euler in Clojure – Problem 7

In trying to learn Clojure and wrap my head around good functional programming, and hoping to learn more idiomatic Clojure, I have started working through the Project Euler problems. In doing this, I have also setup a repository on github.com to keep track of my progress, which can be found at https://github.com/stevenproctor/project-euler-clojure.  My approach to Problem 6 can be found here.

Problem 7 of Project Euler is described as:

`What is the 10 001st prime number?`
```(defn is-prime? [n]
(cond (&lt;= n 1) false
(= n 2) true
:else (loop [f 2]
(cond (zero? (rem n f)) false
(&gt; f (Math/sqrt n)) true
:else (recur (inc f))))))

(defn problem7
([] (problem7 10001))
([n] (first (skip-n (dec n) (filter is-prime? (iterate inc 1))))))
```

The is-prime? function check to see if the number is prime by checking if any of the numbers from 2 to the square root of the number is a divisor of the number.

The problem7 function is finds the n-th number in the sequence by skiping n-1 items, and then taking the first item of that sequence. This was before a previous post in which someone pointed out that the drop function was available instead of my home rolled skip-n function, so that can be replaced on the update.

Again, I would love comments and suggestions on my solution to this problem, and if there are tweaks to make it more Clojure-ish.

**Update**
My solution to Problem 8 has been posted.

–Proctor

# Project Euler in Clojure – Problem 6

In trying to learn Clojure and wrap my head around good functional programming, and hoping to learn more idiomatic Clojure, I have started working through the Project Euler problems. In doing this, I have also setup a repository on github.com to keep track of my progress, which can be found at https://github.com/stevenproctor/project-euler-clojure.  My approach to Problem 5 can be found here.

Problem 6 of Project Euler is described as:

```Find the difference between the sum of the squares of the
first one hundred natural numbers and the square of the sum.```

This is another problem that seems to translate almost directly from the problem statement into the operations that need to be performed.

I find the square of the sums from 1 to the (inc n), where n is bound to 100 for the problem definition, as I want the number that n is bound to to be included in the range. This is coded as:

```(Math/pow (reduce + (range 1 (inc n))) 2)
```

As well as I find the sum of the squares from 1 to the (inc n).

```(reduce + (map #(Math/pow % 2) (range 1 (inc n))))
```

I then pieced these two solutions together, subtracting the two values. When doing this at the REPL, it gave the result as an exponent, which I didn’t like the look of, so I put the function bigint around the subtraction function, giving the full solution as:

```(defn problem6
([] (problem6 100))
([n] (bigint (-
(Math/pow (reduce + (range 1 (inc n))) 2)
(reduce + (map #(Math/pow % 2) (range 1 (inc n))))))))
```

Again, I would love comments and suggestions on my solution to this problem, and if there are tweaks to make it more Clojure-ish.

**Update**
My solution to Problem 7 can be found here.

–Proctor

# Project Euler in Clojure – Problem 5

In trying to learn Clojure and wrap my head around good functional programming, and hoping to learn more idiomatic Clojure, I have started working through the Project Euler problems. In doing this, I have also setup a repository on github.com to keep track of my progress, which can be found at https://github.com/stevenproctor/project-euler-clojure.  My approach to Problem 4 can be found here.

Problem 5 of Project Euler is described as:

```What is the smallest positive number that is evenly
divisible by all of the numbers from 1 to 20?```

In reading this problem I realized that this is just another way to state:

```Find the Least Common Multiple of all of the numbers between 1 and 20.
```

The solution I came up with is:

```(ns project-euler.core
(:require [clojure.string :as string]
clojure.math.numeric-tower))

(defn problem5
([] (problem5 20))
([n] (reduce lcm 1 (range 2 (inc n)))))
```

I found that previous to Clojure 1.2 there was a math library in Clojure-Contrib, which after 1.2 is now been moved to clojure.math.numeric-tower, so that now gets included in the vector of libraries in the :require of the ns function.

Once I had this, it was now just as simple as calling the reduce function with the function lcm, feeding it a initialization value of 1 to the reduce function and having that operate on the range of numbers from 2 to the number bound to the var n, which when called without parameters will use the value of twenty as specified in the problem definition. By defining the different arities for the function problem5, it allowed me to call the function with different numbers to the results of the function, as the full description gave the solution for the numbers in the range of 1 through 10.

Again, I would love comments and suggestions on my solution to this problem, and if there are tweaks to make it more Clojure-ish.

**Update**
My solution to Problem 6 has been posted here.

–Proctor