uroybd

(defn move
  ([dvec direction indx]
   (cond (= direction :up) (move dvec :swap indx (dec indx))
         (= direction :down) (move dvec :swap indx (inc indx))
         :else (println "Wrong Number of args")))
  ([dvec direction indx1 indx2]
   (if (= direction :swap)
     (assoc dvec indx2 (nth dvec indx1) indx1 (nth dvec indx2))
     (println "Invalid arguments"))))

uroybd

(use 'pl.danieljanus.tagsoup)
(use 'hiccup.core)

(defn parser [input]
  (pl.danieljanus.tagsoup/parse
   (java.io.ByteArrayInputStream.
    (.getBytes
     (slurp input)))))

(defn dissoc-all [dmap keys]

uroybd

(use 'pl.danieljanus.tagsoup)
(use 'hiccup.core)

(defn parser [file_path]
  (pl.danieljanus.tagsoup/parse (java.io.ByteArrayInputStream. (.getBytes (slurp file_path)))))

(defn attr_filter [element]
  (cond
    (map? element) {}
    (=  (type []) (type element)) (mapv identity (map attr_filter element))

uroybd

(defn bigboy [x]
  (reduce + (distinct (concat (take-nth 3 (range x)) (take-nth 5 (range x))))))

(loop [start 1 end (Integer/parseInt (read-line))]
  (when (<= start end)
    (println (bigboy (Integer/parseInt (read-line))))
    (recur (inc start) end)))

uroybd

(loop [test-case-remaining (Integer/parseInt (read-line))]
  (while (not= 0 test-case-remaining)
    (do (println (let [factorial (fn [n]
                                   (reduce * (take n (range 1 (inc n)))))
                       to-the-power (fn [n m]
                                      (reduce * (repeat m n)))
                       e-to-the-power-x (fn [x]
                                          (inc (apply + (map #(float (/ (to-the-power x %)
                                                                        (factorial %)))
                                                             (range 1 10)))))]