La sfida

Data una n x nmatrice di numeri interi conn >= 2

1 2
3 4

e un elenco di numeri interi con esattamente 2nelementi

[1,2, -3, -1]

emette la matrice ruotata. Questa matrice è realizzata nel modo seguente:

• Prendi il primo numero intero nell'elenco e ruota la prima riga a destra di questo valore.
• Prendi il numero intero successivo e ruota la prima colonna verso il basso di questo valore.
• Prendi il numero intero successivo e ruota la seconda riga a destra di questo valore, ecc. Fino a quando non hai ruotato una volta ogni riga e colonna della matrice.

L'elenco può contenere numeri interi negativi, il che significa che si sposta la riga / colonna a sinistra / in alto anziché a destra / in basso. Se il numero intero è zero, non ruotare la riga / colonna.

Esempio usando l'input sopra

Elemento elenco Matrice Spiegazione
-------------------------------------------------- ----------
1 2 1 Ruota la prima fila a destra di 1
                   3 4

2 2 1 Ruota la 1a colonna verso il basso di 2
                   3 4

-3 2 1 Ruota la seconda fila a sinistra di 3
                   4 3

-1 2 3 Ruota la seconda colonna in su di 1
                   4 1

Regole

• È possibile scegliere il formato di input più conveniente. Metti in chiaro quale usi.
• Funzione o programma completo consentiti.
• Regole predefinite per input / output.
• Si applicano scappatoie standard .
• Questo è code-golf , quindi vince il conteggio dei byte più basso. Tiebreaker è una presentazione precedente.

Casi test

Il formato di input qui è un elenco di elenchi per la matrice e un elenco normale per gli interi.

[[1,2], [3,4]], [1,2, -3, -1] -> [[2,3], [4,1]]
[[1,2], [3,4]], [1,1,1,1] -> [[3,2], [4,1]]
[[1,2], [3,4]], [0,0,0,0] -> [[1,2], [3,4]]
[[1,2, -3], [- 4,5,6], [7, -8,0]], [1, -2,0, -1,3,4] -> [[7, 5,0], [- 3, -8,2], [- 4,1,6]]
[[1,2, -3], [- 4,5,6], [7, -8,0]], [3,12, -3,0, -6, -3] -> [[1 , 2, -3], [- 4,5,6], [7, -8,0]]

Buona programmazione!

CJam, 13 byte

{{a.m>1m<z}/}

Un blocco senza nome (funzione) che prende la matrice e l'elenco in cima allo stack (in quell'ordine) e lascia al loro posto la nuova matrice.

Esegui tutti i casi di test.

Stessa idea, stesso conteggio byte, implementazioni diverse:

{{\(@m>a+z}/}
{{(Im>a+z}fI}
{{:\Im>]z}fI}

Spiegazione

Idealmente, vogliamo trattare ogni istruzione nella stessa lista e usarla solo per ruotare la prima riga della matrice. Questo può essere fatto abbastanza facilmente trasformando un po 'la matrice dopo ogni istruzione e assicurandosi che tutte quelle trasformazioni extra si annullino alla fine. Quindi, dopo aver elaborato ciascuna istruzione, ruotiamo tutte le righe di una in alto (in modo tale che l'istruzione successiva lungo la stessa dimensione elabori la riga successiva) e quindi trasponiamo la matrice, in modo che stiamo effettivamente elaborando le colonne successive. Queste trasformazioni aggiuntive sono ortogonali alle istruzioni nell'elenco e hanno un periodo di esattamente 2n, proprio ciò di cui abbiamo bisogno.

Per quanto riguarda il codice:

{      e# For each instruction...
  a    e#   Wrap it in a singleton array.
  .m>  e#   Combine it element-wise with the matrix to rotate right. This is
       e#   a fairly common idiom to apply a binary operation only to the first
       e#   element of an array, since element-wise operations just retain all the
       e#   unpaired elements of the longer array.
  1m<  e#   Rotate the rows one up.
  z    e#   Transpose.
}/

APL (Dyalog Extended) , 17 15 14 13 byte

-3 byte di Adám

(⍉1⊖⌽`@1⍢⌽)/⌽

Provalo online!

Prende l'input come un elenco in cui il primo elemento è la matrice e gli elementi rimanenti sono gli importi di rotazione. Se ⌽ ruotasse a destra invece che a sinistra, questo batterebbe CJam.

(⍉1⊖⌽@1 1⍢⌽)/⌽    Monadic train:
(⍉1⊖⌽@1 1⍢⌽)      Helper function to rotate and transpose once.
                        Takes args ⍺ (amount to rotate) and ⍵ (current array)
     ⌽                 Function to rotate left
        1 1             2-element vector containing 1.
                        The second 1 is redundant, but saves 1 byte over (,1).
     ⌽@1 1             Function to rotate the 1st row left by ⍺.
     ⌽@1 1⍢⌽          Reverse ⍵, rotate 1st row left by ⍺, then reverse again.
                        This rotates the first row of ⍵ to the *right*.
  1⊖                   Rotate all the rows upward,
 ⍉                                                 then transpose.
(⍉1⊖⌽@1 1⍢⌽)/⌽   Fold (/) this function over the reversed input.
                     If our input is ⍵, ⍺_1, ⍺_2, ..., ⍺_2n,
                     the reversed input will be ⍺_2n, ..., ⍺_1, ⍵.
                     The / operator applies the function right to left,
                     so the ⌽ is necessary.

Python 2, 96 byte

def f(m,v):
    for i,x in enumerate(v):x%=len(m);r=m[i/2];m[i/2]=r[-x:]+r[:-x];m=zip(*m)
    return m

test

frestituisce un elenco di tuple. Ogni riga nel corpo della funzione è indentata con 1 carattere di tabulazione.

Stax , 12 byte

ÄBí•`»O╒┬g½ë

Esegui ed esegui il debug