hacker-rank-scratch.clj

(ns prime)

;; (coll, n) -> coll'
(defn- prime-check [coll n]
  (empty? (filter #(zero? (mod n %)) coll)))

(defn is-prime? [n]
  (loop [prime-list [] value 2]
    (cond
     ;; Have the list, check for prime
     (> value (Math/sqrt n)) (prime-check prime-list n)
     ;; Still building
     (true? (prime-check prime-list value))
        (recur (conj prime-list value) (inc value))
     :else
        (recur prime-list (inc value)))))

(defn dissoc-vec [coll idx]
  (concat (subvec coll 0 idx)
          (subvec coll (inc idx))))

(defn product-except-index [coll]
  (map #(reduce * (dissoc-vec coll %))
       (range (count coll))))

(defn rep [num lst]
  (doseq [i lst n (range num)]
    (println i)))

((fn [delim lst]
   (let [coll (vec lst)]
     (loop [acc [] i 0]
       (cond
        (= i (count coll)) (doseq [x acc] (println x))
        (> delim (coll i)) (recur (conj acc (coll i)) (inc i))
        :esle (recur acc (inc i)))))) 25 [-41 46 -28 21 52 83 -29 84 27 40])

((fn [lst]
   (let [coll (vec lst)
         odds (map #(coll %)
                   (filter odd? (range (count coll))))]
     (doseq [i odds] (println i)))) [1 2 3 4 5 6])


(defn factorial [n]
  (reduce * (range 1 (inc n))))

(defn pascals-triangle-pos [n r]
  (let [n_fac (factorial n)
        r_fac (factorial r)]
    (/ n_fac (* r_fac (factorial (- n r))))))

(defn pascals-square [k]
  (doseq [i (range 1 (inc k))]
    (let [tier (map #(pascals-triangle-pos (dec i) %) (range i))]
      (println (clojure.string/join " " tier)))))

(pascals-square (Integer/parseInt (read-line)))


(defn string-group [str]
  (let [coll (clojure.string/split str #"")]
    (loop [acc [] part [] v coll]
      (cond
       (nil? (first v)) (if-not (empty? part) (conj acc part) acc)
       (empty? part) (recur acc (conj part (first v)) (rest v))
       (= (first part) (first v)) (recur acc (conj part (first v)) (rest v))
       :else (recur (conj acc part) [(first v)] (rest v))))))

(defn string-compress [s]
  (let [grouped (string-group s)]
    (println
     (apply str (map #(str (first %)
                           (if (= 1 (count %)) "" (count %))) grouped)))))

(string-compress (read-line))