scientific-coder/fib-seq-1.clj

## fib-seq-1.clj
(def fib-seq
  "lazy seq of Fibonacci numbers"
  (lazy-cat [0 1] (map + (rest fib-seq) fib-seq)))


## fib-seq-2.clj
(def fib-seq
  (map first (iterate (fn[[a b]] [b (+ a b)]) [0 1])))

## fizzbuzz.clj
(def fizzbuzz
"lazy seq of fizzbuzz"
  (lazy-seq (map #(let [s (str (if (zero? (rem % 3)) "Fizz")
                               (if (zero? (rem % 5)) "Buzz"))]
                    (if (empty? s) % s))
                 (iterate inc 1))))

## fizzbuzzzapp.clj
(def fizzbuzzzapp
"lazy seq of fizzbuzzzapp more interesting (imo)than fizzbuzz
 because it starts to pay off to factor some code "
(lazy-seq (map #(let [s (apply str (for [[val name] [[3 "Fizz"]
                                                     [5 "Buzz"]
                                                     [7 "Zapp"]]]
                                     (if (zero? (rem % val)) name)))]
                  (if (empty? s) % s))
               (iterate inc 1))))

## menu-cgrand.clj
(defn menu [budget items ]
  "items is a collection of [food price] by C.Grand
returns the combination of food and total price with max price <= budget"
  (letfn [(submenus [items]
            (if-let [[[food price] & xs] (seq items)]
              (let [menus (submenus xs)]
                (concat menus (for [[m p] menus
                                    :let [p (+ p price)]
                                    :when (<= p budget)]
                                [(conj m food) p])))
              [[#{} 0]]))]
    (apply max-key second (submenus items))))

(menu 1505 [["Mixed Fruit" 215]["French Fries" 275]["Side Salad" 335]["Hot Wings" 355]["Mozzarella Sticks" 420]["Sampler Plate" 580]] )

## menu-reduce.clj
(defn menu [budget items]
  "items is a collection of [food price]
returns the combination of food and total price with max price <= budget"
  (apply max-key second
         (reduce (fn [current-menus [food price]]
                   (reduce  (fn [cc-menus [current-menu current-price]]
                              (let [new-price (+ current-price price)]
                                (if (<= new-price budget)
                                  (conj cc-menus [(conj current-menu food) new-price])
                                  cc-menus)))
                            current-menus
                            current-menus))
                 [[[] 0]]
                 items)))

(menu 1505 [["Mixed Fruit" 215]["French Fries" 275]["Side Salad" 335]["Hot Wings" 355]["Mozzarella Sticks" 420]["Sampler Plate" 580]] )

## menu-reduce2.clj
(defn menu
   "items is a collection of [food price] by C.Grand
returns the combination of food and total price with max price <= budget"
  [budget items]
  (->
    (reduce (fn [menus [food price]]
              (into menus (for [[total foods] menus
                                :let [p (+ total price)]
                                :when (<= p budget)]
                            [p (conj foods food)])))
            (sorted-map 0 #{}) items)
    rseq
    first))

(menu 1505 [["Mixed Fruit" 215]["French Fries" 275]["Side Salad" 335]["Hot Wings" 355]["Mozzarella Sticks" 420]["Sampler Plate" 580]] )

## menu-ugly.clj
(defn menu [items budget]
  "items is a collection of [food price]
 returns the combination of food and total price with max price <= budget"
  (apply max-key #(get % 1); take max price
         (filter (fn [[food price]] (<= price budget )); budget restriction
                 (for [ i (range 0 (bit-shift-left 1 (count items)))]
                   (reduce  (fn [[food price] [f p]] [(conj food f) (+ price p)])
                            [[] 0]; combine food and sum prices
                            (keep-indexed #(if (not= 0 (bit-and i (bit-shift-left 1 %1)))
                                             %2)
                                          items))))))

(menu [["Mixed Fruit" 215]["French Fries" 275]["Side Salad" 335]["Hot Wings" 355]["Mozzarella Sticks" 420]["Sampler Plate" 580]] 1505)
	(def fib-seq
	"lazy seq of Fibonacci numbers"
	(lazy-cat [0 1] (map + (rest fib-seq) fib-seq)))
	(def fib-seq
	(map first (iterate (fn[[a b]] [b (+ a b)]) [0 1])))
	(def fizzbuzz
	"lazy seq of fizzbuzz"
	(lazy-seq (map #(let [s (str (if (zero? (rem % 3)) "Fizz")
	(if (zero? (rem % 5)) "Buzz"))]
	(if (empty? s) % s))
	(iterate inc 1))))
	(def fizzbuzzzapp
	"lazy seq of fizzbuzzzapp more interesting (imo)than fizzbuzz
	because it starts to pay off to factor some code "
	(lazy-seq (map #(let [s (apply str (for [[val name] [[3 "Fizz"]
	[5 "Buzz"]
	[7 "Zapp"]]]
	(if (zero? (rem % val)) name)))]
	(if (empty? s) % s))
	(iterate inc 1))))