**Find the sum of all even fibonacci numbers not greater than 4000000**

The fibonacci series has a simple recursive definition, just like factorial

fibonacci(0) = 0 fibonacci(1) = 1 fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)

As before, the Clojure solution is a simple application

(defn euler-2 [n] (loop [a 0 b 1 acc 0] (cond (< n b) acc (even? b) (recur b (+ a b) (+ acc b)) :else (recur b (+ a b) acc)))) (euler-2 4000000)

This works, but this is not a very reusable solution. Having to rewrite the same function each time for a specific case is not something you should be doing.

Storing a list of fibonacci terms is a great way to encapsulate them. Assume we already have this list, then the same problem can be very simply solved.

(reduce + (take-while #(< % 4000000) fibonacci-list))

take-whileis a variation of thetakefunction,taketakes the first n terms in a list.(take 3 (range 100)) =>(0 1 2)

take-whiletakes a predicate function and a list and returns a list of successive terms satisfying the function(take-while #(< % 5) (range 100)) =>(0 1 2 3 4)

See how much simpler that is to understand and read. The problem is that the fibonacci series in an infinite series. You could create a really large list but its impossible to know just how big is big enough. Fortunately Clojure has built in support for lazy-sequences.

Lazy-sequences are infinite lists which only generate terms when required. Clojure has a set of functions which can be used to create lazy-sequences, functions like *repeat*, *cycle* and *iterate* all generate lazy sequences.

**warning:** Do not evaluate an infinite sequence at the REPL as this will result in an infinite loop.

repeatis used to create finite or infinite sequences of the same term(repeat 5 "F") =>("F" "F" "F" "F" "F") (repeat "F") =>("F" "F" "F" ...)

cycletakes a list as argument an returns an infinite sequence of the list repeated.(cycle (range 5)) =>(0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 ...)

iteratetakes a function and value and returns a lazy sequence of x, (f x) (f (f x)) …(iterate inc 0) =>(0 1 2 3 4 5 ...)where inc is the increment function

Now onto something a little more basic. In Clojure lists are evaluated, that is, the first term is taken as a function and is applied to the remaining terms in the list.

There are times when you just want a list of terms without evaluation. This is what the *quote *function is for.

(+ 1 2 3) =>6 (quote (+ 1 2 3)) =>(+ 1 2 3)

quote can also be written as the symbol ‘ before the start of the list.

'(1 2 3) =>(1 2 3)

The * concat* function concatenates its arguments which are lists

(concat '(1 2 3) '(4 5 6)) =>(1 2 3 4 5 6)

*lazy-cat* can be used to concatenate infinite lists

(lazy-cat '(0 1) (iterate inc 2)) =>(0 1 2 3 4 ...)

One more feature of Clojure to go before we implement the lazy fibonacci sequence

In Clojure, a function can take a variable number of arguments and also dispatch differently on the number of arguments called, this is known as polymorphism

(defn add ([a] a) ([a b] (+ a b))) (add 1) =>1 (add 1 2) =>3

*add* if called with 1 argument returns the argument itself and if called with 2 returns the sum of the 2 terms.

Now onto the infinite fibonacci

(defn create-fibonacci-list ([] (create-fibonacci-list 0 1)) ([a b] (lazy-cat (list a b) (create-fibonacci-list b (+ a b))))) (def fibonacci-list (create-fibonacci-list))

The

listfunction takes an arbitrary number of terms and creates a list out of them(list 1 2 3 4) =>(1 2 3 4)

(take 10 fibonacci-list) =>(0 1 1 2 3 5 8 13 21 34)

Problem 7: Primes « The Philosophy and the Craft(00:46:39) :[…] The prime numbers are intriguing, there is no pattern and no direct formula for the nth term in the series of primes. While an nth term formula would be enough for this problem, it would be far more useful to have an infinite, lazy list of primes like the fibonacci list in my earlier post. […]