fizzbuzzseqrepl1.clj

user=> (range 1 16)
(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
user=> (defn is-multiple-of? [num n]
  #_=>   (= 0 (rem n num)))
#'user/is-multiple-of?
user=> (def is-multiple-of-3?
  #_=>   (partial is-multiple-of? 3))
#'user/is-multiple-of-3?
user=> (is-multiple-of-3? 3)
true
user=> (is-multiple-of-3? 5)
false
user=> (def is-multiple-of-5?
  #_=>   (partial is-multiple-of? 5))
#'user/is-multiple-of-5?
user=> (is-multiple-of-5?  3)
false
user=> (is-multiple-of-5?  5)
true
user=> (defn fizz [n s]
  #_=>   (if (is-multiple-of-3? n)
  #_=>     (str s "Fizz")
  #_=>     s))
#'user/fizz
user=> (fizz 3 "")
"Fizz"
user=> (fizz 4 "")
""
user=> (defn buzz [n s]
  #_=>   (if (is-multiple-of-5? n)
  #_=>     (str s "Buzz")
  #_=>     s))
#'user/buzz
user=> (buzz 3 "")
""
user=> (buzz 5 "")
"Buzz"
user=> (map fizz (range 1 16) (repeat 16 ""))
("" "" "Fizz" "" "" "Fizz" "" "" "Fizz" "" "" "Fizz" "" "" "Fizz")
user=> (map buzz (range 1 16) (repeat 16 ""))
("" "" "" "" "Buzz" "" "" "" "" "Buzz" "" "" "" "" "Buzz")
user=> (map (fn [n s] (if (= s "") (str n) s))
  #_=>      (range 1 16)
  #_=>      (map buzz (range 1 16) (map fizz (range 1 16) (repeat 16 ""))))
("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
user=> (defn empty-str-to-number [n s]
  #_=>   (if (= s "") (str n) s))
#'user/empty-str-to-number
user=> (map empty-str-to-number ; <- recursive application of map
  #_=>      (range 1 16)
  #_=>      (map buzz
  #_=>           (range 1 16)
  #_=>           (map fizz
  #_=>                (range 1 16)
  #_=>                (repeat 16 ""))))
("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
user=> (def transformations (list fizz buzz empty-str-to-number))
#'user/transformations
user=> (defn transform [functions numbers strings]
  #_=>   (if (empty? functions)
  #_=>     strings
  #_=>     (recur (rest functions) numbers (map (first functions) numbers strings))))
#'user/transform
user=> (transform transformations (range 1 16) (repeat 16 ""))
("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
user=> (def a-vec [1 2 3 4 5 6 7 8 9 10 11 12 13 14 15])
#'user/a-vec
user=> (transform transformations a-vec (repeat (count a-vec) ""))
("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")
user=> (defn fiz-buzz-numbers [coll transformations]
  #_=>   (let [transform (fn [functions numbers result]
  #_=>                     (if (empty? functions)
  #_=>                       result
  #_=>                       (recur (rest functions)
  #_=>                              numbers
  #_=>                              (map (first functions) numbers result))))]
  #_=>     (transform transformations coll (repeat (count coll) ""))))
#'user/fiz-buzz-numbers
user=> (fiz-buzz-numbers a-vec transformations)
("1" "2" "Fizz" "4" "Buzz" "Fizz" "7" "8" "Fizz" "Buzz" "11" "Fizz" "13" "14" "FizzBuzz")