Obbiettivo

Dato un array 2D di qualsiasi dimensione, scrivere un programma o una funzione per spostare alternativamente le colonne e le righe

Esempio

a b c d e
f g h i j
k l m n o

Tutti gli elementi del primo spostamento di colonna lungo una riga, il secondo spostamento di colonna su una riga, il terzo spostamento lungo una riga e così via, incarto quando raggiungono il bordo.

k g m i o
a l c n e
f b h d j  

Tutti gli elementi nella prima riga si spostano verso destra , il secondo verso sinistra , il terzo verso destra ecc., Avvolgendosi quando raggiungono il bordo.

o k g m i
l c n e a
j f b h d

Seguirò la tradizione di selezionare il codice di lavoro più breve come la migliore risposta

Buccia , 7 byte

‼ozṙİ_T

Provalo online!

Spiegazione

‼ozṙİ_T  Implicit input: a list of lists.
‼        Do this twice:
      T   Transpose,
 oz       then zip with
    İ_    the infinite list [-1,1,-1,1,-1,1,..
   ṙ      using rotation. This rotates the rows in alternating directions.

MATL , 13 byte

,!tZy:oEq2&YS

Provalo online!

Spiegazione

,        % Do twice
  !      %   Transpose. Takes input implicitly the first time
  t      %   Duplicate
  Zy     %   Size. Gives a vector with numbers of rows and of columns
  :      %   Range from 1 to the first entry of the vector (number of rows)
  o      %   Parity: gives 0 or 1 for eacn entry
  Eq     %   Times 2, minus 1: transforms 0 into -1
  2      %   Push 2
  &YS    %   Circularly shift along the second dimension. This shifts the
         %   first row by 1 (that is, to the right), the second by -1 (to
         %   the left), etc.
         % End (implicit). Display (implicit)

J , 26, 21 19 byte

-5 byte grazie alle miglia

(|."_1~_1^#\)@|:^:2

Spiegazione:

^:2 - ripetere due volte quanto segue:

@|: - trasporre e

#\ - trova la lunghezza dei prefissi (1, 2, 3 ... righe)

_1^ - aumenta -1 ai poteri sopra, creando un elenco di -1 1 -1 1 alternati ...

|."_1~ - ruotare ciascuna riga dell'array di input con offset dall'elenco precedente

Provalo online!

Versione originale:

(($_1 1"0)@#|."0 1])@|:^:2

Come funziona

^:2 - ripetere due volte quanto segue:

|: - trasporre e

|."0 1] - ruota ogni riga dell'array di input, offset nell'elenco:

@# - il numero di righe nell'array

($_1 1"0) - alternato _1 1 (3 -> _1 1 _1)

Provalo online!

Wolfram Language (Mathematica) , 55 byte

Nest[MapIndexed[RotateLeft[#,(-1)^#2]&,Thread@#]&,#,2]&

Provalo online!

Python 2 , 83 byte

x=input()
exec'x=[l[i%2*2-1:]+l[:i%2*2-1]for i,l in enumerate(zip(*x))];'*2
print x

Provalo online!

APL + WIN, 30 byte

Richiede l'inserimento dello schermo di un array 2d

((↑⍴m)⍴¯1 1)⌽((1↓⍴m)⍴¯1 1)⊖m←⎕

APL (Dyalog Unicode) , 26 byte

{(¯1 1⍴⍨≢⍵)⌽(¯1 1⍴⍨≢⍉⍵)⊖⍵}

Provalo online!

Prefisso Dfn.

Come?

{(¯1 1⍴⍨≢⍵)⌽(¯1 1⍴⍨≢⍉⍵)⊖⍵}⍝ Main function, prefix. Input matrix is ⍵.
                        ⊖⍵}⍝ Rotate the columns of ⍵ according to the left arg:
            (       ⍉⍵)    ⍝ Transpose ⍵ (makes a 3x5 matrix become 5x3)
                   ≢       ⍝ Tally (yields the number of rows of the matrix)
                  ⍨        ⍝ Swap arguments of the following fn/op
                 ⍴         ⍝ Shape
             ¯1 1          ⍝ This vector. This yields a vector of ¯1 1 with size = number of columns of ⍵.
          ⌽                ⍝ Rotate the rows of ⍵ according to the left arg:
{(¯1 1⍴⍨≢⍵)                ⍝ Does the same as the preceding expression, without transposing ⍵.

APL (Dyalog Unicode) , 15 byte (SBCS)

{⍵⌽⍨¯1*⍳≢⍵}∘⍉⍣2

Provalo online!

JavaScript (ES6), 94 91 byte

a=>(g=a=>a[0].map((_,i)=>(b=a.map(a=>a[i]),i%2?[...b.slice(1),b[0]]:[b.pop(),...b])))(g(a))

C'è probabilmente un modo più golfista per fare la rotazione ...

Pyth, 15 byte

L.e.>b^_1k.Tbyy

Provalo online

Spiegazione

L.e.>b^_1k.Tbyy
L           b      Define a function on a list...
          .T       ... which transposes it...
 .e.>b^_1k         ... and rotates each row alternating left and right.
             yyQ   Apply twice to the (implicit) input array.

q / kdb + , 32 byte

Soluzione:

{rotate'[#:[x+:]#-1 1](+)x}/[2;]

Esempio:

q)3 5#.Q.a / reshape "a..o" into 3 row, 5 column grid
"abcde"
"fghij"
"klmno"
q){rotate'[#:[(+)x]#-1 1](+)x}/[2;]3 5#.Q.a
"okgmi"
"lcnea"
"jfbhd"

Spiegazione:

Capovolgi la griglia per applicare la rotazione alle colonne , la seconda iterazione si ribalta nuovamente, quindi la rotazione viene applicata alle righe al secondo passaggio.

La rotazione si basa sull'elenco -1 1 -1 1..della lunghezza della riga / colonna che viene ruotata.

Un sano 9 byte sono stati golfed fuori da questo più facile da leggere la versione

{rotate'[count[flip x]#-1 1;flip x]}/[2;] / ungolfed solution
{                                  }/[2;] / perform lambda 2 times
 rotate'[                  ;      ]       / perform rotate on each-both
                            flip x        / flip x<->y of grid
                      #-1 1               / take from list -1 1
         count[flip x]                    / the length of the flipped grid

JavaScript (ES6),  116  76 byte

m=>(g=m=>m[0].map((_,x)=>m.map(_=>m[y++%h][x],h=m.length,y=x&1||h-1)))(g(m))

Provalo online!

Commentate

m => (                 // m[] = input matrix
  g = m =>             // g is the main helper function taking a matrix m[]
    m[0].map((_, x) => // for each column at position x in m[]:
      m.map(_ =>       //   for each row of m[]:
        m[y++ % h][x], //     yield the x-th value of the row (y mod h) and increment y
        h = m.length,  //     h = number of rows
        y = x & 1      //     start with y = 1 if x is odd,
            || h - 1   //     or h - 1 if x is even
      )                //   end of inner map()
  )                    // end of outer map()
)(g(m))                // invoke g twice on the input matrix

Gelatina , 10 byte

ZJ-*ṙ"@Zµ⁺

Provalo online!

Pulito , 93 byte

import StdEnv,StdLib
k=[0,1:k]
^l=[[[last a:init a],tl a++[hd a]]!!b\\a<-transpose l&b<-k]

^o^

Come una funzione parziale letterale, sembra che sia una faccia.

Provalo online!

05AB1E , 14 byte

2FøvyNÉiÀëÁ}})

Provalo online!

Spiegazione

2F               # 2 times do:
  ø              # zip
   vy            # for each row(y), index(N) do:
     NÉiÀ        # if N is odd, rotate left
         ëÁ      # else rotate right
           }}    # end if and inner loop
             )   # wrap in list

APL NARS, 36 byte, 18 caratteri

c←b∘b←{⍵⌽⍨-×-\⍳≢⍵}∘⍉

Questo {⍵⌽⍨- × - \ ⍳≢⍵} ruoterebbe ogni riga dell'argomento matrice seguendo il vettore -1 1 -1 1 ecc (che ha la sua lunghezza vettore la lunghezza delle righe matrice argomento). Test:

  ⎕←a←3 5⍴⎕A
ABCDE
FGHIJ
KLMNO
  ⎕←c a
OKGMI
LCNEA
JFBHD

bash et al, 84

Soluzione shell non competitiva.

Questo si basa su una funzione che alterna la direzione della rotazione delle file. La stessa procedura eseguita sull'array trasposto ruoterà le colonne. Per esempio transpose | rotate | transpose | rotate.

La rotazione alternata può essere eseguita su matrici a carattere singolo in sedquesto modo:

sed -E 's/(.*) (.)$/\2 \1/; n; s/^(.) (.*)/\2 \1/'

La trasposizione può essere effettuata con rso datamash:

rs -g1 -T
datamash -t' ' transpose

Presi insieme:

r() { sed -E 's/(.*) (.)$/\2 \1/; n; s/^(.) (.*)/\2 \1/'; }
t() { rs -g1 -T; }
<f t | r | t | r

Produzione:

o k g m i
l c n e a
j f b h d