316 PurelyFunctional.tv Newsletter - Puzzle - https://purelyfunctional.tv/issues/purelyfunctional-tv-newsletter-316-avoid-licensing-and-support-issues-with-the-right-jdk-for-you/

00 drop-every Puzzle Description.md

Drop every nth element from a sequence

The problem is simple: write a function that takes a number n and a sequence. The function returns a new sequence with every nth element removed.

For example:

(drop-every 3 [:a :b :c :d :e :f :g])
;=> (:a :b :d :e :g)

Bonus points for laziness, efficiency, and concision.

https://purelyfunctional.tv/issues/purelyfunctional-tv-newsletter-316-avoid-licensing-and-support-issues-with-the-right-jdk-for-you/

Note: These solutions are untested. Testing them is left as an exercise for you.

Alan Thompson.clj

(defn drop-every
  [n coll]
  (flatten (partition-all (dec n) n coll)))

(drop-every 2 (range 1 13)) => (1 3 5 7 9 11)
(drop-every 3 (range 1 13)) => (1 2 4 5 7 8 10 11)
(drop-every 5 (range 1 13)) => (1 2 3 4 6 7 8 9 11 12)

Caio Oliveira.org

PF.tv challenge

Let’s first write a function to check the outputs. Since it’s quite simple, I’ll use the example from the problem definition and a couple of corner cases:

(defn spy [x] (prn x) x)

(defn seqs-match? [a b]
  ;; we don't care about size because the input might be an infinite seq
  (every? (partial apply =) (zipmap a b)))

(defn check-fn [f]
  (doseq [{:keys [testcase expected]} [{:testcase [3 [:a :b :c :d :e :f :g]], :expected [:a :b :d :e :g]}
                                       {:testcase [3 [:a :b :c :d :e :f :g :h :i]], :expected [:a :b :d :e :g :h]}
                                       {:testcase [3 [:a :b]], :expected [:a :b]}
                                       {:testcase [3 (range)], :expected [0 1 3 4 6 7 9 10 12]}
                                       {:testcase [3 []], :expected []}]
          :let [actual (apply f testcase)]]
    (if (seqs-match? actual expected)
      (println "Match!")
      (do (println "Mismatch :(")
          (println (str "  Expected: " (pr-str expected)))
          (println (str "  Actual  : " (pr-str actual)))))))

The simplest way I could think of was indexing the collection and filtering it:

(defn drop-every-simple [n coll]
  (->> coll
       (map-indexed (fn [index v] [(mod (inc index) n) v]))
       (filter (complement #(-> % first zero?)))
       (map second)))

(check-fn drop-every-simple)

We can also write an arity to return an xform for it:

(defn drop-every
  ([n]
   (comp
    (map-indexed (fn [index v]  [(mod (inc index) n) v]))
    (filter (complement #(-> % first zero?)))
    (map second)))
  ([n coll]
   (sequence (drop-every n) coll)))

(check-fn drop-every)

David Goldfarb.clj

(defn drop-every [n s]
   (mapcat (partial take (dec n))
          (partition n s)))

Dene Wallace.clj

(defn drop-every [n values] 
  (flatten (map #(take (- n 1) %) (partition-all n values))))

Julien Rouse.clj

(defn drop-every
  [n seq]
  (let [seq-indexed (map-indexed #(vec [%1 %2]) seq)]
    (for [[index val] seq-indexed
          :when (or (< (inc index) n)
                    (not (= 0 (mod (inc index) n))))]
      val)))

Neil McCallum.clj

(defn drop-every
  [n coll]
  (->> coll
       (partition-all (dec n) n)
       flatten))

(drop-every 3 [:a :b :c :d :e :f :g])
;; => (:a :b :d :e :g)

Paul Roush.clj

(defn drop-every-nth [n coll]
  (lazy-seq
    (when-let [vals (seq coll)]
      (concat (take (dec n) coll)
              (drop-every-nth n (drop n coll))))))

Peter Strömberg.clj

(defn drop-every [nth coll]
  (keep-indexed #(when (< 0 (rem (inc %1) nth)) %2) coll))

Pieter Breed.clj

(defn drop-every [n xs] 
  (->> xs 
         (map vector (range)) 
         (map (fn [[a b]] [(inc a) b])) 
         (filter (fn [[a b]] (not= 0 (mod a n)))) 
         (map (fn [[a b]] b))))

Steve Miner.clj

(defn drop-every
  ([n]
   {:pre [(pos-int? n)]}
   (fn [rf]
     (let [iv (volatile! n)]
       (fn
         ([] (rf))
         ([result] (rf result))
         ([result input]
          (if (zero? (vswap! iv unchecked-dec))
            (do (vreset! iv n) result)
            (rf result input)))))))

  ([n coll]
   (sequence (drop-every n) coll)) )

Valentin Waeselynck.clj

(defn drop-every 
  [n coll]
  (->> coll 
    (cons :dummy-1st-element)
    (partition-all n)
    (mapcat rest)))

Vincent Cantin.clj

(defn drop-every [n coll]
  (apply concat (partition-all (dec n) n coll)))