; P01 - general version for lists and vectors
(defn p01 [l]
  (let [n (next l)]
    (if (nil? n) (first l) (recur n))
  )
)

; P01 - use destructing assignment, works for lists and vectors
(defn p01' [l]
  (let [[head & rest] l]
    (if (nil? rest) head (recur rest))
  )
)

; P01 - version works only for vectors
(defn p01'' [l]
  (get l (- (count l) 1))
)

; P02 - modified from p01'; works for lists; slightly modification needed to work with vectors
(defn p02 [l]
  (let [[first second & rest] l]
    (if (nil? rest) (into (empty l) [second first]) (recur (next l)))
  )
)

; P03 - general version for lists and vectors
(defn p03 [l n]
  (if (= n 1) (first l) (recur (next l) (- n 1)))
)

; P03 - version works only for vectors
(def p03' #(% (- %2 1)))

; P04 - recursive version, for lists and vectors
(defn p04 [l]
  (if (nil? l) 0 (+ 1 (p04 (next l))))
)

; P04 - tail recursive version, for lists and vectors
(defn p04'
  ([l n] (if (nil? l) n (recur (next l) (inc n))))
  ([l] (p04 l 0))
)

; P04 - built-in version
(def p04'' count)

; P05 - tail recursive lisp-style, for lists and vectors, though it will reverses a vector to a list
(defn p05
  ([l acc] (if (nil? l)
    acc
    (recur (next l) (cons (first l) acc))
  ))
  ([l] (p05 l nil))
)

; P05 - built-in version, it will also reverses a vector to a list
(def p05' reverse)

; P06 - simple version using P05: only works for lists
(def p06 #(= % (reverse %)))

; P07 - based on P05; only works for lists
(defn p07
  ([l acc] (if (nil? l)
    acc
    (if (list? l)
      (recur (next l) (p07 (first l) acc))
      (cons l acc)
    )
  ))
  ([l] (reverse (p07 l nil)))
)

(def p07' flatten)

; P08 - based on P05; only works for lists
(defn p08
  ([l acc] (if (nil? l)
    acc
    (recur (next l)
      (if (= (first l) (first acc))
        acc
        (cons (first l) acc)
      )
    )
  ))
  ([l] (reverse (p08 l nil)))
)

; P09 - based on P05; only works for lists
(defn p09
  ([l acc] (if (nil? l)
    acc
    (recur (next l)
      (if (= (first l) (first (first acc)))
        (cons (cons (first l) (first acc)) (next acc))
        (cons (list (first l)) acc)
      )
    )
  ))
  ([l] (reverse (p09 l nil)))
)

; P10 - using built-in map and count function
(defn p10 [l]
  (map #(list (count %) (first %)) (p09 l))
)