task_stack.clj

(ns hello.core
  (:require [clojure.string :as str]))

(defn parse-int [^String n]
  (Integer/parseInt n))

(defn parse-cmd
  [arg]
  (let [splitted (str/split arg #"\s")]

    (concat [(first splitted)]
            (some->> (next splitted)
                     (map parse-int)))))

(defn main
  []
  (let [N (parse-int (read-line))]
    (loop [stack (lazy-seq '()) i 0 length 0]
      (when (> i 0)
          (let [item (first stack)]
            (if (nil? item)
              (println "EMPTY")
              (println item)))) ; peek
      (when (< i N)
        (let [cmd (-> (read-line)
                      parse-cmd)]
          (case (first cmd)
            "pop"
            (recur (rest stack)
                   (inc i)
                   (dec length))
            "push"
            (recur (conj stack (second cmd))
                   (inc i)
                   (inc length))
            "inc"
            (let [depth (second cmd)
                  x (last cmd)
                  [a b] (split-at (- length depth) stack)]
              (recur (lazy-cat a (map #(+ % x) b))
                     (inc i)
                     length))))))))