(let [capacity 8]
  (reduce #(if (< (reduce + %1) capacity) (conj %1 %2) %1) [] (range 20)))

[0 1 2 3 4]

(let [x '(a b c)] (vector `(1 2 ~x 3) `(1 2 ~@x 3)))

[(1 2 (a b c) 3) (1 2 a b c 3)]

(let [make-seq (fn make-seq [start-value]
                 (lazy-seq (cons start-value (make-seq (inc start-value)))))
      a (make-seq 1)]
  (take 4 a))

(1 2 3 4)

(let [fns [inc #(mod % 100) #(* % %)]] (reduce #(%2 %1) 104 fns))

25

(->> [1 2 3]
     (mapcat #(list x %))
     (apply +)
     with-out-str
     (defn totes [])
     (let [x 15]))

#'user/totes

(let [a 23] (doseq [b (range 24)] (print (mod (min (- a b) (- b a)) 24))))

nil

"12345678910111213141516171819202122230"

(let [x (lazy-cat (do (println 1) [1])
                  (do (println 2) [2])
                  (do (println 3) [3]))]
  (first x))

1

"1\n"

(let [{a :a, b :b} {:a 5, :b 6} [x y] (range 2)] [a b x y])

[5 6 0 1]

(let (zipmap2 #(map %1 (vector %2 %3)))
     (zipmap2 identity [1 2 3 4] [:dog :cat :bat]))

([1 2 3 4] [:dog :cat :bat])

(let [[a b c *xs] '(1 2 3 4 5 6 7)] (+ a b c))

6

(let [fibos (atom nil)]
  (reset! fibos (lazy-cat [0 1] (map + @fibos (rest @fibos))))
  (take 10 @fibos))

(0 1 1 2 3 5 8 13 21 34)

(let [vals [1 2 3 4 5]] (every? true? (map #(< %1 %2) vals (rest vals))))

true

(let [m {:foo "foo", :bar "bar"}]
  (merge m (apply hash-map (mapcat (fn [[a b]] [b a]) m))))

{:bar "bar", :foo "foo", "bar" :bar, "foo" :foo}

(let [apply-if #(if (%1 %3) (%2 %3) %3)]
  (map #(apply-if odd? inc %) (range 10)))

(0 2 2 4 4 6 6 8 8 10)

(defn magic
  [elt coll]
  (let [[xs ys] (split-with #(not= elt %) coll)] (concat xs (rest ys))))

#'user/magic

(let [x [1 2 3 4 5 7]]
  (clojure.set/difference (set (range 1 (inc (last x)))) (set x)))

#{6}

(let [a "foo"
      b (apply str (seq "foo"))]
  [(identical? a b) (identical? a (get #{a} b))])

[false true]

(defn make-query
  [arg1 arg2]
  (let [query (atom {:value ""})]
    (swap! query update-in [:value] str arg1 "::" arg2)))

#'user/make-query

(remove false? (map #(let [x (* % %)] (if (even? x) x false)) (range 1 10)))

(4 16 36 64)

(let [x 1]
  (-> x
      inc
      (as-> y
        (-> y
            (+ 10)
            (as-> z [x y z])))))

[1 2 12]

(let [m {:foo 1, :bar 2}] (map (fn [a b] '(a b)) (keys m) (vals m)))

((a b) (a b))

(let [zipmap2 #(map %1 (vector %2 %3))]
  (zipmap2 identity [1 2 3 4] [:dog :cat :bat]))

([1 2 3 4] [:dog :cat :bat])

(let [{[f & r] :items} {:hp 100, :mana 10, :items '[sword bread apple hammer]}]
  [f r])

[sword (bread apple hammer)]

(binding [*print-length* 64]
  (let [a (object-array 64)
        v (vec a)]
    (aset a 0 :hi)
    (prn v)))

nil

"[nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil]\n"

(let [v [3 1 6 4] i (apply max-key v (range (count v)))] [i (v i)])

[2 6]

((fn [arg]
   (let [[last last-1 last-2] (reverse arg)]
     (println "last 3: " last-2 last-1 last)))
  (range 10))

nil

"last 3:  7 8 9\n"

(let [x (lazy-seq (cons (do (println "ein") 1)
                        (lazy-seq (cons (do (println "twei") 2) nil))))]
  (first x))

1

"ein\n"

(let [m {:hoo 38, :boy 12, :yeah 384, :okay 49}]
  (zipmap (shuffle (range (count m))) (vals m)))

{0 12, 1 384, 2 38, 3 49}

(defn byte-seq
  [input-stream]
  (lazy-seq (let [value (.read input-stream)]
              (if (= value -1) nil (cons val (byte-seq input-stream))))))

#'user/byte-seq

(let [x 0]
  (cond (< x 0) (print "neg")
        (> x 0) (print "pos")
        true (print "zero")))

nil

"zero"

(clojure.string/join " "
                     (let [coll [1 2 3 [10 20] 4]] (mapcat #(vector % %) coll)))

"1 1 2 2 3 3 [10 20] [10 20] 4 4"

(let [funcs {:a inc, :b dec}
      values {:b 5, :a 10}]
  (merge-with #(%1 %2) funcs values))

{:a 11, :b 4}

(defn apply-regex-rules
  [rulesMap file]
  (let [apply-rule? (fn [rule] (re-seq rule file))]
    (map #(apply-rule? %) (keys rulesMap))))

#'user/apply-regex-rules

(let [f str] (reduce-kv (fn [m k v] (assoc m k (f v))) {} {:a 1, :b 2}))

{:a "1", :b "2"}

(let [in '[a b a b a b a b]] (apply map list (partition 2 in)))

((a a a a) (b b b b))

(let [s "Leonidas   "
      f (fn [[key re]] (when (re-find re s) key))]
  (some f {"found!" #"Leonidas\S*"}))

"found!"

(defmacro fn-with-bindings
  [args & body]
  `(let [bindings# (clojure.lang.Var/getThreadBindings)]
     (fn ~args
       (try (clojure.lang.Var/pushThreadBindings bindings#)
            ~@body
            (finally (clojure.lang.Var/popThreadBindings))))))

#'user/fn-with-bindings

(let [start "22"
      pad-char \:
      desired-length 10]
  (str (apply str (repeat (- desired-length (count start)) pad-char)) start))

"::::::::22"

(let [state (atom {:plots [[1 2] [1 5]]})]
  (do (swap! state update-in [:plots 0 1] inc) @state))

{:plots [[1 3] [1 5]]}

(let [freqs (frequencies [:a :a :b :b :b :b :c :d :e :f])]
  (apply max-key val freqs))

[:b 4]

(defmacro defalias
  [dst src]
  `(let [v# (var ~src)]
     (doto (def ~dst @v#) (alter-meta! (constantly (meta v#))))))

#'user/defalias

(let [m {} m {:a 5, :b (:a m)} m {:a 5, :b (:a m)}] m)

{:a 5, :b 5}

(let [m {:x 1, :y 2}] (reduce (fn [res [k v]] (assoc res k (inc v))) {} m))

{:x 2, :y 3}

(let [backing (into-array (cons 5 (repeat 20 nil)))
      v (vec backing)]
  (aset backing 0 7)
  v)

[7 nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil nil
 nil]

(let [xs [[:a 1 2 3] [:b 4 5 6]]] (#(zipmap (map first %) %) xs))

{:a [:a 1 2 3], :b [:b 4 5 6]}

(let [[a b c] (re-matcher #".*test.*" "this is a test. testing. only a test.")]
  [a b c])

[nil nil nil]

(let [v [:a :b :c] i 1] (into (subvec v 0 i) (subvec v (inc i))))

[:a :c]

(let [kvs (repeatedly 20 #(rand-int 100))]
  (println "kvs =" kvs "\nsorted-map =" (seq (apply sorted-map kvs))))

nil

"kvs = (0 69 75 59 91 6 28 5 94 24 87 99 91 21 96 51 32 55 49 87) \nsorted-map = ([0 69] [28 5] [32 55] [49 87] [75 59] [87 99] [91 21] [94 24] [96 51])\n"

(let [rep {"name" "World", "greeting" "Hello"}]
  (clojure.string/replace "<greeting> <name>" #"<(.*?)>" #(get rep (%1 1))))

"Hello World"

(let [i 2] (reduce (fn [c p] (if (p i) (inc c) c)) 0 [odd? even? pos?]))

2