Le défi

Étant donné une n x mmatrice avec n > 1et m > 1 rempli d'entiers

1 2 3
4 5 6

et une liste d'entiers avec exactement autant de valeurs que de 2x2blocs dans la matrice ( (n-1)*(m-1)si vous avez besoin du nombre exact)

[1, 2]

Sortez la matrice avec chaque 2x2bloc tourné par la valeur actuelle dans la liste dans l'ordre donné. L'exemple ci-dessus donnerait

4 6 2
5 3 1

Le premier bloc est tourné une fois vers la droite et le deuxième bloc est tourné deux fois vers la droite.

Remarques

• Un entier positif signifie que vous tournez à droite de ce nombre d'étapes.
• Un entier négatif signifie que vous tournez à gauche de ce nombre d'étapes.
• Un zéro signifie que vous ne tournez pas.
• Vous faites pivoter les blocs en ligne. Cela signifie que vous commencez dans la première rangée et allez à droite. Une fois que vous avez fait pivoter chaque bloc de cette ligne, vous passez au suivant. À la fin, chaque bloc a été tourné exactement une fois.
• Gardez à l'esprit que les blocs se chevauchent. La première matrice ci-dessus a les blocs [[1,2],[4,5]]et [[2,3],[5,6]]par exemple.
• Chaque rotation d'un bloc affecte la rotation sur les blocs adjacents. C'est pourquoi vous devez effectuer les rotations dans le modèle décrit ci-dessus.

Règles

• Vous pouvez prendre l'entrée dans le format le plus pratique. Veuillez préciser dans votre réponse celle que vous utilisez. Cela ne vous permet cependant pas de lire la matrice par blocs.
• Fonction ou programme complet autorisé.
• Règles par défaut pour les entrées / sorties.
• Des échappatoires standard s'appliquent.
• Il s'agit de code-golf , donc le nombre d'octets le plus bas l'emporte. Tiebreaker est une soumission antérieure.

Cas de test

Le format d'entrée est ici une liste de listes pour la matrice et une liste normale pour les valeurs.

[[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]]

Codage heureux!

CJam ( 42 40 octets)

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

Démo en ligne

Fondamentalement, cela applique deux fois la même technique afin de plier le bloc

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

qui fonctionne sur une matrice 2x2 et un certain nombre de fois pour tourner.

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

peut être traité avec

.{block}

et a pour effet de

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

car .(comme %dans CJam) ne rassemble pas les résultats dans un tableau tant qu'il n'est pas terminé.

CJam, 65 63 60 55 octets

Il doit y avoir une meilleure façon de le faire ...

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

Il s'agit d'une fonction sans nom qui attend les instructions et la matrice (dans cet ordre) sur la pile et laisse la matrice résultante à leur place.

Testez-le ici.

Explication

Je n'ai pas envie d'écrire la ventilation complète du code en ce moment, alors voici un aperçu approximatif:

• La manipulation du tableau 2D est une douleur dans CJam, donc je déroule plutôt la matrice, calcule chaque rotation comme une permutation des éléments à des positions spécifiques, puis divise à nouveau le tableau en lignes à la fin. La largeur de la matrice est stockée dans N.
• Une rotation à la position kdans la matrice déroulée change quatre indices: k <- k+1, k+1 <- k+1+N, k+N <- k, k+1+N <- k+1. Pour chaque index le klong de la liste d'instructions, je calcule une permutation correspondant à cela et l'applique au tableau d'entrée déroulé.
• Cela laisse le problème, dans le tableau linéaire, certaines rotations seront positionnées avec son coin supérieur gauche dans la dernière colonne de l'entrée. Pour les ignorer, je riffle des zéros dans la liste d'instructions, de sorte que ces sous-blocs 2x2 invalides sont techniquement traités, mais avec un no-op.

Python 2 , 166 159 octets

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

Essayez-le en ligne!