Unconditional FizzBuzz using a regex, for any multiples m1 (the fizz) < m2 (the buzz), m1 > 1 assumed

gistfile1.txt

(defn fizzbuzz 
  ([m1 m2 n]
   (let [ c #(->> % vector (concat (-> %2 dec (repeat nil))) cycle)
         fb-re #"Fizz|Buzz|FizzBuzz"]
     (->> [(c "Fizz" m1), (c "Buzz" m2)]
          (apply map 
                 (fn [i m1 m2]
                   (or (re-matches fb-re (str m1 m2))
                       i))
                 (range 1 (inc n))))))
  ([n]
   (fizzbuzz 3 5 n)))

;;
;; Spec'ing fizzbuzz as practice in learning clojure.spec
;;
(require '[clojure.spec :as s] '[clojure.spec.test :as stest])
(s/def ::posint (s/and integer? pos?))
(s/def ::fizzbuzz (s/and 
                   (s/alt :_1-arg ::posint
                          :_3-arg (s/cat :n1 (s/and ::posint #(< 1 %))
                                         :n2 ::posint
                                         :limit ::posint))
                   (fn [[_ {:keys [n1 n2 limit]}]]
                     (if n1
                       (< n1 n2 limit)
                       true))))

(def fizzbuzz-inout-valid? 
  #(let [mult1 (or (-> % :args :_3-arg :n1) 3)
         mult2 (or (-> % :args :_3-arg :n2) 5)
         n (or (-> % :args :_3-arg :limit)
               (-> % :args :_1-arg))]
     (and (= n (count (-> % :ret)))
          (->> (-> % :ret)
               (map (fn [i x]
                      (cond 
                        (= 0 (rem i mult1)(rem i mult2))
                        (= "FizzBuzz" x),                        
                        (zero? (rem i mult1))
                        (= "Fizz" x),
                        (zero? (rem i mult2))
                        (= "Buzz" x),
                        :else
                        (= i x)))
                    (range 1 (inc n)))
               (every? identity)))))

(s/fdef fizzbuzz 
        :args ::fizzbuzz
        :ret (s/* (s/alt :num ::posint
                         :fizz #(= "Fizz" %)
                         :buzz #(= "Buzz" %)
                         :fizzbuzz #(= "FizzBuzz")))
        :fn fizzbuzz-inout-valid?)

(stest/instrument `fizzbuzz)