Die Herausforderung

Gegeben eine n x nMatrix von ganzen Zahlen mitn >= 2

1 2
3 4

und eine Liste von ganzen Zahlen mit genau 2nElementen

[1,2, -3, -1]

gibt die gedrehte Matrix aus. Diese Matrix ist folgendermaßen aufgebaut:

• Nehmen Sie die erste Ganzzahl in der Liste und drehen Sie die erste Zeile um diesen Wert nach rechts.
• Nehmen Sie die nächste Ganzzahl und drehen Sie die erste Spalte um diesen Wert nach unten.
• Nehmen Sie die nächste Ganzzahl und drehen Sie die zweite Zeile um diesen Wert usw. nach rechts, bis Sie jede Zeile und Spalte der Matrix einmal gedreht haben.

Die Liste kann negative Ganzzahlen enthalten, was bedeutet, dass Sie die Zeile / Spalte nach links / oben statt nach rechts / unten verschieben. Wenn die Ganzzahl Null ist, drehen Sie die Zeile / Spalte nicht.

Beispiel mit der obigen Eingabe

Listenelement Matrix Erläuterung
-------------------------------------------------- ----------
1 2 1 1. Reihe um 1 nach rechts drehen
                   3 4

2 2 1 Drehen Sie die 1. Säule um 2 nach unten
                   3 4

-3 2 1 2. Reihe links um 3 drehen
                   4 3

-1 2 3 Drehen Sie die 2. Säule um 1 nach oben
                   4 1

Regeln

• Sie können das bequemste Eingabeformat auswählen. Stellen Sie einfach klar, welches Sie verwenden.
• Funktion oder Vollprogramm erlaubt.
• Standardregeln für die Eingabe / Ausgabe.
• Es gelten Standardlücken .
• Dies ist Code-Golf , also gewinnt die niedrigste Byte-Anzahl. Tiebreaker ist eine frühere Vorlage.

Testfälle

Das Eingabeformat ist hier eine Liste von Listen für die Matrix und eine normale Liste für die ganzen Zahlen.

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

Viel Spaß beim Codieren!

CJam, 13 Bytes

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

Ein unbenannter Block (Funktion), der die Matrix und die Liste (in dieser Reihenfolge) auf den Stapel legt und die neue Matrix an ihrer Stelle belässt.

Führen Sie alle Testfälle aus.

Gleiche Idee, gleiche Byteanzahl, unterschiedliche Implementierungen:

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

Erläuterung

Im Idealfall möchten wir jede Anweisung in der Liste gleich behandeln und sie nur zum Drehen der ersten Zeile der Matrix verwenden. Dies kann ganz einfach geschehen, indem die Matrix nach jedem Befehl ein wenig transformiert wird und sichergestellt wird, dass sich alle diese zusätzlichen Transformationen am Ende aufheben. Nachdem wir jeden Befehl verarbeitet haben, drehen wir alle Zeilen um eins nach oben (sodass der nächste Befehl in derselben Dimension die nächste Zeile verarbeitet) und transponieren dann die Matrix, sodass wir tatsächlich die nächsten Spalten verarbeiten. Diese zusätzlichen Transformationen sind orthogonal zu den Anweisungen in der Liste und haben genau den Zeitraum 2n, den wir benötigen.

Wie für den Code:

{      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 ausgefahren) , 17 15 14 13 Bytes

-3 Bytes von Adám

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

Probieren Sie es online!

Nimmt die Eingabe als Liste, wobei das erste Element die Matrix ist und die verbleibenden Elemente die Rotationsbeträge sind. Wenn ⌽ nach rechts statt nach links gedreht wird, schlägt 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 Bytes

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

Tests

fgibt eine Liste von Tupeln zurück. Jede Zeile im Funktionskörper wird mit 1 Tabulatorzeichen eingerückt.

Stax , 12 Bytes

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

Führen Sie es aus und debuggen Sie es