Last time I explained lazy-when functionand how it helps me in solving euler problems. Now I`ll introduce additional similar functions, and then as always, I`m gonna use them in a couple of euler problems.

First, consider all the times when you need lazy functions that check if the number has more then one property. I wanted to re-write lazy-when to accept a collection of predicates and check the number on all of them:

(defn all? [pred-coll]I used all? to transform predicate function. It checks if pred is a collection. If not, it returns pred, but if it is then it returns another function that checks the number on all predicates. The rest of the function is pretty-much same.

(if (coll? pred-coll) (fn [n] (every? #(% n) pred-coll)) pred-coll))

(defn lazy-when

([pred s] (lazy-when pred s inc))

([pred n next-n]

(let [pred-f (all? pred)]

(if-not (pred-f n)

(recur pred-f (next-n n) next-n)

(lazy-seq (cons n (lazy-when pred-f (next-n n) next-n)))))))

Quite often, I need the first number from the lazy seq after some other number:

(defn lazy-next [pred s & next]

(let [next (if (nil? next) inc (first next))]

(let [s (if ((all? pred) s) (next s) s)]

(first (lazy-when pred s next)))))

With next I did the same thing as in lazy-when. S transformation, however, is interesting. If pred returns true for s, then lazy-next would return that value too. And if you have a loop where you recur on each number from a lazy function, that loop would become infinite, and you usualy don't want that. So s is transformed to the next value that would otherwise be checked only if pred returns false for s.

This function will not serve for prime numbers. If I offer s 2 and next step #(+ % 2), then it would check even numbers and never return. However, if I offer inc for the next step, then my lazy-next becomes much slower. That`s why I created next-prime, as the special case of lazy-next when predicate is prime?

(defn next-prime [prime]Finally, euler usually looks for the sum of this-and-that numbers under x. For that reason, I wrote the following functions:

(if (= prime 2) 3 (lazy-next prime? prime #(+ % 2))))

(defn lazy-top [pred s end until? & next]

(let [next (if (nil? next) inc (first next))]

(take-while #(until? % end) (lazy-when pred s next))))

(defn lazy-sum [pred s end until? & next]

(let [next (if (nil? next) inc (first next))]

(reduce + (lazy-top pred s end until? next))))

Little more than one-liners, but the pattern is there often enought so why not have it as a function?

Now, with those, to solve the problem from the last post all it takes is:

(time (println (+ 2 (lazy-sum prime? 3 (reduce * 2 (repeat 6 10)) < #(+ 2 %) ))))

Lets try something else. Problem 046 I only need to discover if the number can be written as the sum of a prime and twice a square, and I have it all:

(defn goldbach? [n]

(loop [prime 2 root 1]

(let [goldbach (+ prime (* 2 root root))]

(cond (= n goldbach) true

(> prime (dec n)) false

(> goldbach n) (recur (next-prime prime) 1)

:else (recur prime (inc root))))))

(time (println (lazy-next [#(not (prime? %)) #(not (goldbach? %))] 33 #(+ % 2))))