((fn weird-shit [n]
   (if (even? n)
     (partition 2 (range 1 (inc n)))
     (concat (weird-shit (dec n)) [[(dec n) n]])))
  15)

((1 2) (3 4) (5 6) (7 8) (9 10) (11 12) (13 14) [14 15])

((fn inc-leaf [m]
   (if (map? m) (zipmap (keys m) (map inc-leaf (vals m))) (inc m)))
  {:a 5, :b {2 3}})

{:a 6, :b {2 4}}

(let [f #(fn [& y] (apply % (reverse y)))]
  ((f map) (replicate 3 (range 3)) ((f partial) inc map)))

((1 2 3) (1 2 3) (1 2 3))

(let [f0 "C:\\long\\fn.ext"
      f1 (apply str (take (.lastIndexOf f0 ".") f0))]
  (apply str (drop (inc (.lastIndexOf f1 "\\")) f1)))

"fn"

(reduce #(update-in % [(if (zero? (mod %2 2)) :evens :odds)] inc)
  {:evens 0, :odds 0}
  (range 1 20))

{:evens 9, :odds 10}

(->> (range (* x 10) (* (inc x) 10))
     (partition 2)
     (map vec)
     (into {})
     (for [x (range 10)])
     (into {}))

{0 1,
 2 3,
 4 5,
 6 7,
 8 9,
 10 11,
 12 13,
 14 15,
 16 17,
 18 19,
 20 21,
 22 23,
 24 25,
 26 27,
 28 29,
 30 31,
 32 33,
 34 35,
 36 37,
 38 39,
 40 41,
 42 43,
 44 45,
 46 47,
 48 49,
 50 51,
 52 53,
 54 55,
 56 57,
 58 59,
 60 61,
 62 63,
 64 65,
 66 67,
 68 69,
 70 71,
 72 73,
 74 75,
 76 77,
 78 79,
 80 81,
 82 83,
 84 85,
 86 87,
 88 89,
 90 91,
 92 93,
 94 95,
 96 97,
 98 99}

(let [state (atom {})
      counter (fn [s] (swap! state update-in [s] (fnil inc 0)))]
  (mapv counter ["hi" "hi" "bye"])
  @state)

{"bye" 1, "hi" 2}

(reduce #(if (= %2 42) (reduced %1) (inc %1))
  (iterate #(bit-xor % (bit-shift-left 1 (rand-int 8))) 12))

520

(apply (fn [& xs] (if (and (seq xs) (< (first xs) 1000)) (recur (rest xs)) 17))
  (iterate inc 0))

17

(defn foo2
  [n]
  (let [n (int n)] (loop [i (int 0)] (if (< i n) (recur (inc i)) i))))

#'user/foo2

(letfn [(dechunk [xs]
          (lazy-seq (when (seq xs) (cons (first xs) (dechunk (next xs))))))]
  (first (map prn (dechunk (iterate inc 1)))))

nil

"1\n"

(let [atm (atom 100)
      coll {:a atm, :b atm}]
  (do (swap! atm inc) (reset! (:a coll) 5) @(:b coll)))

5

(letfn [(find-idx [k c] (reduce #(if (= %2 k) %1 (inc %1)) 0 c))]
  (find-idx :y [:x :y :z]))

2

(into {}
      (map (fn [[k v]] [k (if (even? v) (inc v) v)]) {:a 0, :b 1, :c 2, :d 3}))

{:a 1, :b 1, :c 3, :d 3}

(let [a (atom 0) action (delay (swap! a inc)) f #(force action)] [(f) (f) (f)])

[1 1 1]

(letfn [(map’ [f [x & xs]] (when x (lazy-seq (cons (f x) (map’ f xs)))))]
  (map’ inc (range 3)))

(1 2 3)

(reduce (fn [m k] (update-in m [k] inc)) {:x 1, :y 2, :z 3, :a 4} [:x :y :z])

{:a 4, :x 2, :y 3, :z 4}

(take-while number?
            (let [mutable (atom 0)]
              (repeatedly #(let [r @mutable]
                             (when (< r 5) (swap! mutable inc) r)))))

(0 1 2 3 4)

(let [f #(* % %)] (map #(take %1 (iterate f %2)) (iterate inc 1) (range 10 14)))

((10) (11 121) (12 144 20736) (13 169 28561 815730721))

(let [f #(fn [& y] (apply % (reverse y)))]
  ((f map) (replicate 10 (range 10)) (partial map inc)))

((1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10)
  (1 2 3 4 5 6 7 8 9 10))

(if-let [res ((comp peek first) (re-seq #"foo=(\d+)" "this is foo=10"))]
  #_=>
  (-> res
      Integer/parseInt
      inc)
  #_=>
  nil)

11

(let [compose-n-times (fn [f n] (fn [x] (nth (iterate f x) n)))
      plus-10 (compose-n-times inc 10)]
  (plus-10 5))

15

(let [items '(a b c)]
  (reduce (fn [[i acc] x] [(inc i) (conj acc [x i])]) [0 []] items))

[3 [[a 0] [b 1] [c 2]]]

(defn ab
  []
  (let [a (atom 0)] (fn [x] (if (= x :inc) (swap! a inc) (swap! a dec)) @a)))

#'user/ab

(letfn [(mapf [f xs] (reduce (fn [mapped x] (conj mapped (f x))) [] xs))]
  (mapf inc '(1 2 3)))

[2 3 4]

(defn foobar
  [f0]
  (let [f1 (apply str (take (.lastIndexOf f0 ".") f0))]
    (apply str (drop (inc (.lastIndexOf f1 "\\")) f1))))

#'user/foobar

(reduce (fn [acc [k v]] (assoc acc k (inc v))) {} {1 2, 3 4, 5 6, 7 8, 9 0})

{1 3, 3 5, 5 7, 7 9, 9 1}

(map second (filter (fn [[x y]] (= (inc x) y)) (partition 2 1 [1 2 3 5 6 7 8])))

(2 3 6 7 8)

(let [v [{:name "Chris", :age 28} {:name "Adam", :age 25}]
      m (zipmap (map :name v) v)]
  (update-in m ["Chris" :age] inc))

{"Adam" {:age 25, :name "Adam"}, "Chris" {:age 29, :name "Chris"}}

(vector (def ^:dynamic *modulus* 10)
        (defn f
          [x]
          (-> x
              (inc)
              (mod *modulus*)))
        (binding [*modulus* 3] (take 3 (iterate f 1))))

[#'user/*modulus* #'user/f (1 2 3)]

(def cards
  (set (for [suit [:hearts :clubs :spades :diamonds]
             face (concat [:ace :jack :queen :king] (map inc (range 10)))]
         [suit face])))

#'user/cards

(letfn [(tri [n] (if (zero? (mod n 3)) (- n 2) (inc n)))]
  (map (comp tri tri tri) (range -4 4)))

(-4 -3 -2 -1 0 1 2 3)

(zipmap (reverse [:str :dex :con :int :wis :cha])
        (repeatedly
          6
          (fn [] (apply + (rest (sort (repeatedly 4 #(inc (rand-int 6)))))))))

{:cha 15, :con 13, :dex 10, :int 16, :str 15, :wis 10}

(condp #(some %2 %1) [1 2 3 4] #{0 6 7} :>> inc #{4 5 9} :>> dec)

2

(reduce-kv (fn [acc k v] (assoc acc k (inc v))) {} {1 2, 3 4, 5 6, 7 8, 9 0})

{1 3, 3 5, 5 7, 7 9, 9 1}

(defn fire-x-times
  ([x] (fire-x-times x 1))
  ([x i] (when (>= x i) (println "fired" i "times") (recur x (inc i)))))

#'user/fire-x-times

(letfn [(f [s]
          (reduce (fn [acc _]
                    (conj acc
                          (take (-> acc
                                    count
                                    inc)
                                s)))
            []
            s))]
  (f [1 2 3]))

[(1) (1 2) (1 2 3)]

(zipmap [:str :dex :con :int :wis :cha]
        (repeatedly
          6
          (fn [] (apply + (rest (sort (repeatedly 4 #(inc (rand-int 6)))))))))

{:cha 14, :con 18, :dex 15, :int 13, :str 10, :wis 12}

(let [m {:a 1, :b 2, :c 3}]
  (zipmap (map #(str % "-san") (keys m)) (map inc (vals m))))

{":a-san" 2, ":b-san" 3, ":c-san" 4}

(let [remap (fn [f m] (into {} (map (fn [[k v]] {k (f v)}) m)))]
  (remap inc {:a 1, :b 3}))

{:a 2, :b 4}

((fn [p m & c] (apply map #(if (p %) (m %) %) c)) even? inc (range 1 11))

(1 3 3 5 5 7 7 9 9 11)

(let [v [:a :b :c :d :e :f :g]
      idx 2]
  (vec (concat (take idx v) (drop (inc idx) v))))

[:a :b :d :e :f :g]

(reduce (fn [occurances [a b]] (update-in occurances [a b] (fnil inc 0)))
  {}
  (partition 2 1 ["a" "b" "c" "d" "b" "a"]))

{"a" {"b" 1}, "b" {"a" 1, "c" 1}, "c" {"d" 1}, "d" {"b" 1}}

(defn is-prime?
  [x]
  (loop [i 2] (if (>= i x) true (if (= (rem x i) 0) false (recur (inc i))))))

#'user/is-prime?

(let [items (map vector (iterate inc 0) [:a :b :c :d])]
  (some (fn [[i v]] (if (= v :c) i)) items))

2

(defn extract-rand
  [v]
  (let [n (rand-int (count v))]
    [(get v n) (into [] (concat (take n v) (drop (inc n) v)))]))

#'user/extract-rand

(letfn [(f [x] (inc x))]
  (reduce #(assoc %1 (key %2) (f (val %2))) {} {:a 1, :b 2, :c 3}))

{:a 2, :b 3, :c 4}

(defn fire-x-times
  [x]
  (loop [x x
         n 1]
    (when (>= x n) (println "fired" n "times") (recur x (inc n)))))

#'user/fire-x-times

(let [data [[[1 2 3] [4 5 6]] [[7 8 9] [10 11 12]]]]
  (update-in data [1 0 2] inc))

[[[1 2 3] [4 5 6]] [[7 8 10] [10 11 12]]]

(doseq [x (keep-indexed #(str (inc %1) ". " %2 ", ")
                        (shuffle ["Vim" "Emacs" "Coursive" "LT" "Nightcode"]))]
  (print x))

nil

"1. Emacs, 2. LT, 3. Vim, 4. Coursive, 5. Nightcode, "