Clojure Golf: fib-seq

Revisiting a classic:

(def fib-seq
  (lazy-cat [0 1] (map + fib-seq (rest fib-seq))))

Clojure Golf: subsets-by-card (2)

I wasn't happy with the last one. At least this one is lazier and in increasing cardinality order.

(defn subsets-by-card [s]
  (reduce (fn [ssbc x]
           (map (fn [a b] (concat a (map #(conj % x) b)))
             (concat ssbc [nil]) (concat [nil] ssbc)))
    [[#{}]] s))

Decreasing order:

(defn subsets-by-card-reverse [s]
  (reduce (fn [ssbc x]
            (map (fn [a b] (concat a (map #(disj % x) b)))
              (concat ssbc [nil]) (concat [nil] ssbc)))
    [[(set s)]] s))

Clojure Golf: subsets-by-card

(defn subsets-by-card [s]
  (reduce (fn [ssbc x] 
            (concat
              (map (fn [a b] (concat a (map #(conj % x) b)))
                (cons nil ssbc) ssbc)
              [[#{}]]))
    [[#{}]] s))

(a tough one)

Clojure Golf: subsets

(defn subsets [s]
  (reduce (fn [ss x] (concat ss (map #(conj % x) ss))) [#{}] s))

Clojure Golf: combinations (2)

(defn combinations [& cs]
  (reduce #(for [v %1 i %2] (conj v i)) [[]] cs))

Clojure Golf: combinations

(defn combinations [& cs]
  (reduce (fn [vs c] 
           (mapcat #(map conj vs (repeat %)) c))
          [[]] cs))