循环与递归 #

(map inc [1 2 3 4 5])

(filter even? (range 10))

(reduce + [1 2 3 4 5])

(loop [bindings]
  body
  (recur new-values))

(loop [i 0]
  (when (< i 5)
    (println i)
    (recur (inc i))))

(defn sum-to [n]
  (loop [i 1
         sum 0]
    (if (> i n)
      sum
      (recur (inc i) (+ sum i)))))

(sum-to 10)

(defn factorial [n]
  (loop [n n
         acc 1]
    (if (<= n 1)
      acc
      (recur (dec n) (* acc n)))))

(factorial 10)

(factorial 1000)

(defn fibonacci [n]
  (loop [a 0
         b 1
         count 0]
    (if (= count n)
      a
      (recur b (+ a b) (inc count)))))

(map fibonacci (range 10))

(defn find-first [pred coll]
  (loop [coll coll]
    (when (seq coll)
      (if (pred (first coll))
        (first coll)
        (recur (rest coll))))))

(find-first even? [1 3 5 4 7 8])

(find-first pos? [-1 -2 3])

(defn sum [n]
  (if (<= n 0)
    0
    (+ n (sum (dec n)))))

(sum 10)

(sum 10000)

(defn sum-tail [n]
  (letfn [(helper [n acc]
            (if (<= n 0)
              acc
              (recur (dec n) (+ acc n))))]
    (helper n 0)))

(sum-tail 10000)

(defn reverse-list [lst]
  (loop [lst lst
         acc '()]
    (if (empty? lst)
      acc
      (recur (rest lst) (conj acc (first lst))))))

(reverse-list [1 2 3 4 5])

(doseq [x coll]
  body)

(doseq [i [1 2 3 4 5]]
  (println i))

(doseq [x [1 2 3]
        y [:a :b]]
  (println [x y]))

(doseq [x (range 10)
        :when (even? x)]
  (println x))

(doseq [x (range 10)
        :let [y (* x x)]
        :when (> y 10)]
  (println x "->" y))

(doseq [[k v] {:a 1 :b 2 :c 3}]
  (println k "=" v))

(doseq [[i x] (map-indexed vector [:a :b :c])]
  (println i ":" x))

(doseq [x [1 2 3]]
  (* x 2))

(dotimes [i n]
  body)

(dotimes [i 5]
  (println i))

(dotimes [i 3]
  (println "Iteration:" i))

(dotimes [_ 10]
  (print "."))

(while condition
  body)

(def counter (atom 5))
(while (pos? @counter)
  (println @counter)
  (swap! counter dec))

(loop [counter 5]
  (when (pos? counter)
    (println counter)
    (recur (dec counter))))

(defn naturals []
  (iterate inc 0))

(take 5 (naturals))

(take 10 (naturals))

(take 5 (repeat :x))

(take 5 (cycle [1 2 3]))

(take 10 (iterate #(* % 2) 1))

(defn fib-seq []
  (map first
       (iterate (fn [[a b]] [b (+ a b)])
                [0 1])))

(take 10 (fib-seq))

(defn powers-of [n]
  (iterate #(* % n) 1))

(take 10 (powers-of 2))

(defn print-and-return [x]
  (println "Computing:" x)
  x)

(def lazy-result
  (map print-and-return (range 5)))

(take 2 lazy-result)

(for [x [1 2 3 4 5]]
  (* x x))

(for [x [1 2 3]
      y [:a :b]]
  [x y])

(for [x (range 10)
      :when (even? x)]
  x)

(for [x (range 10)
      :let [y (* x x)]
      :when (> y 10)]
  [x y])

(for [x (range 10)
      :while (< x 5)]
  x)

(defn pairs [coll]
  (for [x coll
        y coll
        :when (< x y)]
    [x y]))

(pairs [1 2 3 4])

(defn cartesian-product [coll1 coll2]
  (for [x coll1
        y coll2]
    [x y]))

(cartesian-product [1 2] [:a :b])

(defn binary-search [coll target]
  (loop [low 0
         high (dec (count coll))]
    (if (> low high)
      nil
      (let [mid (quot (+ low high) 2)
            mid-val (nth coll mid)]
        (cond
          (= mid-val target) mid
          (< mid-val target) (recur (inc mid) high)
          :else (recur low (dec mid)))))))

(binary-search [1 2 3 4 5 6 7 8 9] 5)

(binary-search [1 2 3 4 5 6 7 8 9] 10)

(defn quick-sort [coll]
  (if (empty? coll)
    coll
    (let [pivot (first coll)
          rest-coll (rest coll)]
      (concat
        (quick-sort (filter #(< % pivot) rest-coll))
        [pivot]
        (quick-sort (filter #(>= % pivot) rest-coll))))))

(quick-sort [3 1 4 1 5 9 2 6 5])

(defn tree-seq-custom [branch? children root]
  (lazy-seq
    (if (branch? root)
      (cons root (mapcat #(tree-seq-custom branch? children %)
                         (children root)))
      [root])))

(def tree {:value 1
           :children [{:value 2
                       :children [{:value 4} {:value 5}]}
                      {:value 3
                       :children [{:value 6}]}]})

(tree-seq-custom :children :children tree)

(defn process-batch [items batch-size f]
  (loop [items items
         results []]
    (if (empty? items)
      results
      (let [batch (take batch-size items)
            result (f batch)]
        (recur (drop batch-size items)
               (conj results result))))))

(process-batch (range 10) 3
  (fn [batch] (reduce + batch)))

(defn sum-recursive [n]
  (if (<= n 0)
    0
    (+ n (sum-recursive (dec n)))))

(defn sum-tail [n]
  (loop [n n acc 0]
    (if (<= n 0)
      acc
      (recur (dec n) (+ acc n)))))

(time (sum-tail 100000))

(time (sum-recursive 10000))

(defn sum-range [n]
  (reduce + (range n)))

(defn sum-loop [n]
  (loop [i 0 acc 0]
    (if (>= i n)
      acc
      (recur (inc i) (+ acc i)))))