gistfile1.clj

;;euler problem #2
(defn make-fib [limit lst]
  (let [revlst (reverse lst)
        item1 (first revlst)
        item2 (first (rest revlst))
        item3 (+ item1 item2)]
    (conj lst item3)))


(defn generate-fib
  ([limit] (generate-fib limit '[1 2]))
  ([limit lst]
      (if (>= limit (first (reverse lst)))
                  (recur limit (make-fib limit lst))
                  (pop lst))))

(defn sum-fib [limit]
  (let
      [lst (generate-fib limit)
       real-lst (filter even? lst)]
    (reduce + real-lst)))

(defn solve-euler2 []
  (sum-fib 4000000))

;;one liner solution
;;(reduce + (filter even? (take-while #(< % 4e6) (map first (iterate (fn
;[[a b]] [b (+ a b)]) [0 1])))))

;;euler problem #3

;;code from sritchie @ https://gist.github.com/1045258:
(defn prime?
  ([num]
     (prime? num 2 (+ 1 (/ num 2))))
  ([num cur end]
     (or (<= num 2)
         (= cur end)
         (= num cur)
         (if (zero? (mod num cur))
           false
           (recur num (+ cur 1) end)))))

(defn find-prime-after
  [num]
  (if (prime? (+ 1 num))
    (+ 1 num)
    (recur (+ 1 num))))


(defn find-prime-factors
  ([num]
     (find-prime-factors num [2]))
  ([num lst]
;;     (println "num: " num  "lst: " lst)
     (let [final (last lst)]
       (cond
        (<= num final) lst
        (zero? (mod num final)) (recur (/ num final) (conj lst final))
        (not= 0 (mod num final))
        (recur num (conj (subvec lst 0 (- (count lst) 1)) (find-prime-after final)))))))

(defn solve-euler3 []
  (last (find-prime-factors 600851475143)))

;;euler problem 4
;;note: investigate how ->> macro could help
(defn palindrome? [numString]
  (let [firstNum (first numString)
        lastNum (last numString)
        midNum (butlast (rest numString))]
    (cond
     (or (= 1 (count numString)) (zero? (count numString))) true
     (not= firstNum lastNum) false
     (= firstNum lastNum) (recur (apply str midNum))
     )))

(defn palFinder
  ([] (palFinder (for [x (range 999 -1 -1) y (range 999 -1 -1)] [x y]) '()))
  ([numList palList]
     ;;(if (zero? (mod (count numList) 1000)) (println "@" (count numList)))
     (if (not= numList '())
       (let [resNum (* (first (first numList)) (second (first numList)))]
         ;; (println "first: " (first numList))
         ;; (println "resNum: " resNum)
         (if (true? (palindrome? (Integer/toString resNum)))
           (recur (rest numList) (conj palList resNum))
           (recur (rest numList) palList)))
       palList
       )))

(defn findMaxPal []
  (reduce max (palFinder)))

;;euler problem 5
(defn test-nums
  [lst incr]
  (let [test-num (* incr (first lst))]
    (= 20 (count (filter (fn [x] (= 0 (mod test-num x))) lst)))
    ))

(defn find-num-by-list
  ([] (let [lst (range 20 0 -1)] (find-num-by-list lst 1)))
  ([lst incr]
     (if (test-nums lst incr)
       (* incr (first lst))
       (recur lst (+ 1 incr)))))

;;euler problem 6
(defn square [x] (* x x))

(defn sum-of-squares [lst]
  (reduce + (map square lst)))

(defn square-of-sum [lst]
  (square (reduce + lst)))

(defn solve-euler6
  (let [lst (range 1 101)]
    (- (square-of-sum lst) (sum-of-squares lst))))