La sfida

Data una n x mmatrice con n > 1e m > 1 piena di numeri interi

1 2 3
4 5 6

e un elenco di numeri interi con esattamente tanti valori quanti 2x2blocchi nella matrice ( (n-1)*(m-1)se hai bisogno del numero esatto)

[1, 2]

Emette la matrice con ogni 2x2blocco ruotato dal valore corrente nell'elenco nell'ordine dato. L'esempio sopra cederebbe

4 6 2
5 3 1

Il primo blocco viene ruotato una volta a destra e il secondo blocco viene ruotato due a destra.

Appunti

• Un numero intero positivo significa che si ruota a destra da quel numero di passaggi.
• Un numero intero negativo significa che ruoti a sinistra per quel numero di passaggi.
• Uno zero significa che non si ruota.
• Ruoti i blocchi in ordine di riga. Ciò significa che inizi nella prima riga e vai a destra. Dopo aver ruotato tutti i blocchi di quella riga, si passa al successivo. Alla fine ogni blocco è stato ruotato esattamente una volta.
• Tieni presente che i blocchi si sovrappongono. La prima matrice sopra ha i blocchi [[1,2],[4,5]]e [[2,3],[5,6]]per esempio.
• Ogni rotazione di un blocco influenza la rotazione sui blocchi adiacenti. Questo è il motivo per cui devi fare le rotazioni nel modello sopra descritto.

Regole

• Puoi prendere l'input nel formato più conveniente. Si prega di specificare nella risposta quale si utilizza. Questo non ti consente di leggere la matrice in termini di blocco.
• 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 i valori.

[[1,2], [3,4]], [-3] -> [[4,1], [3,2]]
[[1,1,1], [1,1,1]], [-333, 666] -> [[1,1,1], [1,1,1]]
[[1,2,3], [4,5,6]], [1,2] -> [[4,6,2], [5,3,1]]
[[1,2,3], [4,5,6], [7,8,9]], [4,0,12, -20] -> [[1,2,3], [4, 5,6], [7,8,9]]
[[1,2,3,4,5], [5,4,3,2,1], [1,2,3,4,5]], [2, -3,4,1,6, 24,21, -5] -> [[4,1,5,2,4], [2,1,3,5,5], [3,2,4,3,1]]

Buona programmazione!

CJam ( 42 40 byte)

{(\@2$,(/.{@a@a+z(\@.{4,={+2/zW%~}*}z~}}

Demo online

Fondamentalmente questo applica due volte la stessa tecnica per piegare il blocco

{4,={+2/zW%~}*}

che opera su una matrice 2x2 e più volte per ruotare.

[first row] [[second row] [third row] ... [last row]] [value_0 value_1 ... value_n]

può essere elaborato con

.{block}

e ha l'effetto di

[first row]
[second row] value_0 {block}~
[third row] value_1 {block}~
...

perché .(come %in CJam) non raccoglie i risultati in un array fino a quando non è finito.

CJam, 65 63 60 55 byte

Ci deve essere un modo migliore per farlo ...

{_e_\z,:N(@/Ta*ee{~4,=,f{;1$,,\[XTN_)]f+_(+er\f=}~}/N/}

Questa è una funzione senza nome che attende le istruzioni e la matrice (in quell'ordine) sullo stack e lascia al loro posto la matrice risultante.

Provalo qui.

Spiegazione

Non ho voglia di scrivere l'intera suddivisione per il codice in questo momento, quindi ecco una panoramica generale:

• La manipolazione di array 2D è una sofferenza in CJam, quindi sto srotolando la matrice, calcolando ogni rotazione come una permutazione degli elementi in posizioni specifiche e quindi dividere nuovamente l'array in righe alla fine. La larghezza della matrice è memorizzata in N.
• Una rotazione in posizione knell'array srotolato cambia quattro indici: k <- k+1, k+1 <- k+1+N, k+N <- k, k+1+N <- k+1. Per ogni indice klungo l'elenco delle istruzioni, calcolo una permutazione corrispondente a questa e la applico all'array di input non srotolato.
• Questo lascia il problema, che nell'array lineare alcune rotazioni verranno posizionate con il suo angolo in alto a sinistra nell'ultima colonna dell'input. Per saltare questi, sfoglio gli zeri nell'elenco delle istruzioni, in modo che questi sub-blocchi 2x2 non validi vengano elaborati tecnicamente, ma con un no-op.

Python 2 , 166 159 byte

A,R=input();m=~-len(A[0])
for j,r in enumerate(R):exec r%4*"a,b,c,d=A[j/m][j%m:][:2]+A[j/m+1][j%m:][:2];A[j/m][j%m:j%m+2]=c,a;A[j/m+1][j%m:j%m+2]=b,d;"
print A

Provalo online!