; P21 - recursive version, modified from p20
(defn p21 [i l n]
  (if (= 1 n) (cons i l)
    (if (nil? l) nil
      (cons (first l) (p21 i (next l) (- n 1)))
    )
  )
)

; P22 - tail recursive version
(defn p22
  ([s e acc]
    (if (< e s) acc
      (recur s (- e 1) (cons e acc))
    )
  )
  ([s e] (p22 s e nil))
)

; P22 - built-in version
(def p22' #(range % (inc %2)))

; P23 - using P20
(defn p23 [l r]
  (let [cl (count l)]
    (if (= r cl) l
      (recur (p20 l (rand-int cl)) r)
    )
  )
)

; P24 - using P22 and P23
(def p24 #(p23 (p22 1 %2) %))

; P25 - using P03 and P20
(defn p25
  ([l acc]
    (if (nil? l) acc
      (let [tk (inc (rand-int (count l)))]
        (recur (p20 l tk) (cons (p03 l tk) acc))
      )
    )
  )
  ([l] (p25 l nil))
)

; P26 - naive brute force algorithm
(defn p26
  [n l]
  (let [aux (fn self [curr rem acc]
    (if (= (count curr) n) (cons (reverse curr) acc)
      (if (nil? rem) acc
        (recur (cons (first rem) curr) (next rem) (self curr (next rem) acc))
      )
    ))]
    (aux nil l nil)
  )
)