挑战

给定一个n x n整数矩阵n >= 2

1 2
3 4

以及具有确切2n元素的整数列表

[1,2，-3，-1]

输出旋转的矩阵。该矩阵的构造方式如下：

• 取列表中的第一个整数，然后将此值向右旋转第一行。
• 取下一个整数并将第一列向下旋转此值。
• 取下一个整数并将第二行向右旋转此值，依此类推，直到将矩阵的每一行和每一列旋转一次。

该列表可以包含负整数，这意味着您将行/列向左/上移，而不是向右/下移。如果整数为零，请不要旋转行/列。

使用上面输入的示例

列表元素矩阵说明
-------------------------------------------------- ----------
1 2 1将第一行右移1
                   3 4

2 2 1将第一列向下旋转2
                   3 4

-3 2 1将第二行左移3
                   4 3

-1 2 3将第二列向上旋转1
                   4 1

规则

• 您可以选择最方便的输入格式。只需弄清楚您使用的是哪一个即可。
• 允许功能或完整程序。
• 输入/输出的默认规则。
• 有标准漏洞。
• 这是代码高尔夫球，因此最低字节数获胜。Tiebreaker是较早提交的内容。

测试用例

输入格式是矩阵列表的列表和整数的普通列表。

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

编码愉快！

CJam，13个字节

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

一个未命名的块（函数），该矩阵将矩阵和列表放在堆栈顶部（按此顺序），并将新矩阵保留在其位置。

运行所有测试用例。

相同的想法，相同的字节数，不同的实现：

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

说明

理想情况下，我们希望将列表中的每条指令视为相同，并仅使用它来旋转矩阵的第一行。通过在每条指令后对矩阵进行一点转换，并确保所有这些额外的转换最后都被抵消，可以很容易地做到这一点。因此，在处理完每条指令之后，我们将所有行向上旋转（以使沿着同一维的下一条指令处理下一行），然后转置矩阵，以便实际上在处理下一列。这些额外的转换与列表中的指令正交，并且周期2n正好是我们所需要的。

至于代码：

{      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扩展），17 15 14 13字节

-3字节，由Adám编写

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

在线尝试！

将输入作为列表，其中第一个元素是矩阵，其余元素是旋转量。如果⌽向右旋转而不是向左旋转，则将击败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字节

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

测验

f返回一个元组列表。函数主体中的每一行都以1个制表符缩进。

Stax，12 个字节

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

运行并调试