Circularly shifting nested vectors

Question

Given a nested vector A

[[1 2 3] [4 5 6] [7 8 9]]

my goal is to circularly shift rows and columns.

If I first consider a single row shift I'd expect

[[7 8 9] [1 2 3] [4 5 6]]

where the 3rd row maps to the first in this case.

This is implemented by the code

(defn circles [x i j]
     (swap-rows x i j))

with inputs

(circles [[1 2 3] [4 5 6] [7 8 9]] 0 1)

However, I am unsure how to go further and shift columns. Ideally, I would like to add to the function circles and be able to either shift rows or columns. Although I'm not sure if it's easiest to just have two distinct functions for each shift choice.

if ```(def v [1 2 3 4])```, then ```(rest (conj v (first v))``` equals ```[2 3 4 1]```. doesn't solve your whole issue but might be a starting point. — Joel M, May 18 '20 at 16:38

score 4 · Accepted Answer · answered Dec 27 '13 at 18:57

(defn circles [xs i j]
  (letfn [(shift [v n]
            (let [n (- (count v) n)]
              (vec (concat (subvec v n) (subvec v 0 n)))))]
    (let [ys (map #(shift % i) xs)
          j  (- (count xs) j)]
      (vec (concat (drop j ys) (take j ys))))))

Example:

(circles [[1 2 3] [4 5 6] [7 8 9]] 1 1)
;= [[9 7 8] [3 1 2] [6 4 5]]

Depending on how often you expect to perform this operation, the sizes of the input vectors and the shifts to be applied, using core.rrb-vector could make sense. clojure.core.rrb-vector/catvec is the relevant function (you could also use clojure.core.rrb-vector/subvec for slicing, but actually here it's fine to use the regular subvec from clojure.core, as catvec will perform its own conversion).

Where is shift defined? I am seeing it a lot, but cannot find its definition anywhere? — octopusgrabbus, Jul 27 '14 at 15:31
@octopusgrabbus In this snippet, it's a local function introduced by the `letfn` form – `(letfn [(shift …)] …)`. — Michał Marczyk, Jul 28 '14 at 02:37

score 2 · Answer 2 · answered Dec 27 '13 at 19:57

You can also use cycle:

(defn circle-drop [i coll]
  (->> coll
       cycle
       (drop i)
       (take (count coll))
       vec))

(defn circles [coll i j]
  (let [n (count coll)
        i (- n i)
        j (- n j)]
    (->> coll
         (map #(circle-drop i %))
         (circle-drop j))))

(circles [[1 2 3] [4 5 6] [7 8 9]] 2 1)
;; => [[8 9 7] [2 3 1] [5 6 4]]

score 2 · Answer 3 · answered Dec 27 '13 at 23:55

There's a function for that called rotate in core.matrix (as is often the case for general purpose array/matrix operations)

The second parameter to rotate lets you choose the dimension to rotate around (0 for rows, 1 for columns)

(use 'clojure.core.matrix)

(def A [[1 2 3] [4 5 6] [7 8 9]])

(rotate A 0 1)
=> [[4 5 6] [7 8 9] [1 2 3]]

(rotate A 1 1)
=> [[2 3 1] [5 6 4] [8 9 7]]

Circularly shifting nested vectors

3 Answers3