Problems five through nine all have relatively simple solutions in Clojure. My apologies for those wanting more length.
We'll start by looking through the numbers one-by-one. Our number must be divisible by 2 and then 3. So the number must be divisible by 2*3. The next divisor, 4=22, meaning that to keep the number minimal, we need have only another single factor of 2 in the number or that the number must be divisible by 2*3*2. Five is a new prime divisor and so the number must be divisible by 2*3*2*5. Continuing in this manner, we can see that divisibility by 6 can be satisfied by the existing factors of 2 and 3, seven can be added to the list, and 8 can be accounted for by adding another factor of 2 to the product, meaning that the number must be divisible by 2*3*2*5*7*2. Nine brings in the second factor of 3 and continuing writing factors in this manner up to 20 (whose divisibility is already accounted for by 2 factors of 2 and one of 5 at that point) leaves us with a number that must be divisible by 2*3*2*5*7*2*3*11*13*2*17*19, which having all the factors of numbers less than or equal to 20 is the solution to the problem.
Using Clojure as a desk calculator gives us the answer:
(defn euler-5 "Expand numbers by prime factors and read off non-dupe factors."  (* 2 3 2 5 7 2 3 11 13 2 17 19))
(defn euler-6  (let [to100 (range 1 101)] (- (* (reduce + to100) (reduce + to100)) (reduce + (map #(* % %) to100)))))
(defn nth-prime [n] (nth (gen-primes) (dec n)))Note the (dec n) - Clojure's counting is zero-based, the problem counts from 1. This allows us to write our solution for Problem 7:
(defn euler-7  (nth-prime 10001))
((\7 \3 \1 \6 \7 \1 \7 \6 \5 \3 \1 \3 \3) (\3 \1 \6 \7 \1 \7 \6 \5 \3 \1 \3 \3 \0) (\1 \6 \7 \1 \7 \6 \5 \3 \1 \3 \3 \0 \6) ...)Each sub-sequence contains the thirteen characters of the substring it corresponds to. To convert these to their products, we must convert the character sequences to integer sequences and multiply. To do the first, we construct an auxiliary function char->int:
(defn char->int [c] (- (int c) (int \0)))Once this function is available, we can solve the problem as follows:
(defn euler-8  (->> (get-partitions) (map #(apply * (map char->int %))) (apply max)))In this solution, we take the partitions, use the map function to get the products, and take the max. The internal function in the map form takes the sequence, converts its characters to integers, and multiplies them together.
(defn euler-9  (->> (triples-summing 1000) (filter pythagorean-triple?) (map #(apply * %)) (first)))The test for being a Pythagorean triple is simple:
(defn pythagorean-triple? [[a b c]] (= (* c c) (+ (* a a) (* b b))))The code for producing a set of all positive integer pairs summing to N is:
(defn doubles-summing [N] (let [rangeN (range 1 (inc N))] (take (dec N) (map (fn [x] [x (- N x)]) rangeN))))Here, we take the numbers i from 1 to N, and use the map function to pair them with N-i. We only use the first N-1 of these because we do not want to consider the number pair [N, 0]. We will use these doubles to find triples summing to N:
(defn triples-summing [N] (apply concat (let [rangeN (range 1 (inc N))] (map (fn [k] (let [doubles (doubles-summing (- N k))] (map (fn [[a b]] [a b k]) doubles))) (take (dec N) rangeN)))))In this function, the first map is applied to the numbers k from 1 to N, where for each it maps the doubles [a, b] summing to N-k and packages them into a triple [a, b, k] summing to N. The sequences of triples produced by this map are then concatenated to form the final list of all triples. Again, note the (take (dec N) ...) clause. This is again because we do not want to consider solutions of the form [a, b, 0], where a+b = N.