Rotate Sequence – Rich 4Clojure Problem 44 – See: https://github.com/PEZ/rich4clojure

rich4clojure_medium_problem_044.clj

(ns rich4clojure.medium.problem-044
  (:require [hyperfiddle.rcf :refer [tests]]))

;; = Rotate Sequence =
;; By 4Clojure user: dbyrne
;; Difficulty: Medium
;; Tags: [seqs]
;; 
;; Write a function which can rotate a sequence in either
;; direction.

(def __ :tests-will-fail)

(comment
  
  )

(tests
  (__ 2 [1 2 3 4 5]) := '(3 4 5 1 2)
  (__ -2 [1 2 3 4 5]) := '(4 5 1 2 3)
  (__ 6 [1 2 3 4 5]) := '(2 3 4 5 1)
  (__ 1 '(:a :b :c)) := '(:b :c :a)
  (__ -4 '(:a :b :c)) := '(:c :a :b))

;; To participate, fork:
;; https://github.com/PEZ/rich4clojure

;; Post your solution below, please!

(defn- rotate [n coll]
  (concat
   (drop n coll)
   (take n coll)))

(defn- rotate-backwards [n coll]
  (concat
   (take-last n coll)
   (drop-last n coll)))

(defn rotate-any-dir [steps coll]
  (let [steps (rem steps (count coll))]
    (if (< steps 0)
      (rotate-backwards (Math/abs steps) coll)
      (rotate steps coll))))

(def __ rotate-any-dir)

(comment
  (mod -4 3)
  ;; normal rotate
  (concat
   (drop 2 [1 2 3 4 5])
   (take 2 [1 2 3 4 5]))
  (rotate 2 [1 2 3 4 5])

  (concat
   (take-last 2 [1 2 3 4 5])
   (drop-last 2 [1 2 3 4 5]))
  
  (rotate-backwards 2 [1 2 3 4 5])

  (rotate-any-dir -4 [1 2 3])
  )

(defn __ [n coll]
  (let [length (count coll)]
    (concat (drop (mod n length) coll)
            (take (mod n length) coll))))

(fn [split-count in-seq]
    "rotate a seq in either direction"
    (apply concat (reverse
           (split-at (mod split-count (count in-seq)) in-seq))))

(fn [n coll] (let [coll-count (count coll)]
    (take coll-count (drop (mod n coll-count) (cycle coll)))))

(def __ (fn [n xs]
          (let [n' (mod n (count xs))
                movers (take n' xs)]
            (concat (drop n' xs) movers))))