有时，我的代码中包含常数矩阵列表：

[ [[1, 0],
   [0, 1]],

  [[1, 0],
   [0,-1]],

  [[0, 1],
   [1, 0]],

  [[0,-1],
   [1, 0]] ]

屏幕空间的使用非常糟糕。我宁愿将它们彼此相邻写：

[   [[1, 0],    [[1, 0],    [[0, 1],    [[0,-1],
     [0, 1]],    [0,-1]],    [1, 0]],    [1, 0]]   ]

您会发现这仍然是一个语法上有效的嵌套列表，它不再是矩形，并且具有非常不同的结构（特别是，每当我添加大于1x1的矩阵时，它就会变得更深）。但是，仍然可以从这个新列表中重建矩阵的初始列表。

为了将来能够使用此语法，我需要您编写一些代码，以将以水平排列方式编写的数组转换为它们表示的矩阵列表。

为确保答案不对源代码中的布局执行2D模式匹配，输入将仅作为数组对象给出，或者如果您采用字符串表示形式，则输入将不包含任何空格以指示文字是用代码编写的。因此，您将获得如下输入：

[[[1, 0], [[1, 0], [[0, 1], [[0,-1], [0, 1]], [0,-1]], [1, 0]], [1, 0]]]

并且输出应为以下数组或其字符串表示形式（同样，不需要进一步的布局）：

[[[1, 0], [0, 1]], [[1, 0], [0,-1]], [[0, 1], [1, 0]], [[0,-1], [1, 0]]]

这是分为两部分的挑战的第一部分，也是较容易的部分。在这一章中，您可以假设所有矩阵都是正方形且尺寸相同，并且彼此正确对齐。在第二部分中，我们将放宽这些假设。

规则

输入将是嵌套列表或其规范的字符串表示形式（使用您选择的语言），并且您应该以相同格式输出结果。结果将始终包含至少一个矩阵，并且矩阵可以小至1x1。矩阵将仅包含绝对值小于128的（带符号）整数。

您可以编写程序或函数，并使用接收输入和提供输出的任何标准方法。

您可以使用任何编程语言，但是请注意，默认情况下，这些漏洞是禁止的。

这是代码高尔夫球，因此以字节为单位的最短有效答案为准。

测试用例

每个测试用例都有：a）列表矩阵很好地排列在一起，就像它们在代码中一样（这不是您的输入），b）没有格式的列表，没有多余的空格（这是您的输入），c）预期的输出。

Pretty: [ [[0]] ]
Input:  [[[0]]]
Output: [[[0]]]

Pretty: [  [[-1]],  [[0]],  [[1]]  ]
Input:  [[[-1]],[[0]],[[1]]]
Output: [[[-1]],[[0]],[[1]]]

Pretty: [  [[1, 0],   [[1, 0],   [[0, 1],   [[0,-1],
            [0, 1]],   [0,-1]],   [1, 0]],   [1, 0]]  ]
Input:  [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]
Output: [[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Pretty: [  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
            [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
            [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]
Input:  [[[1,0,0],[[127,63,31],[[1,0,0],[[0,0,0],[0,1,0],[15,0,-15],[0,0,1],[0,0,0],[0,0,1]],[-31,-63,-127]],[0,1,0]],[0,0,0]]]
Output: [[[1,0,0],[0,1,0],[0,0,1]],[[127,63,31],[15,0,-15],[-31,-63,-127]],[[1,0,0],[0,0,1],[0,1,0]],[[0,0,0],[0,0,0],[0,0,0]]]

果冻，20 15 13 11字节

Fðs⁹œsZµḢḢL

在线尝试！

背景

像大多数事情一样，一旦您确定了必须要做的事情，这一挑战就相当简单。经过三删除和一回滚，我最终做到了...

首先，我们必须弄清楚矩阵的维数。这比说起来容易：第一个元素的第一个元素是第一个输出矩阵的第一行，因此它的长度等于平方输出矩阵的列数。

例如，如果输入是

[  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
    [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
    [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]

第一个元素的第一个元素是[1, 0, 0]，其长度为ℓ= 3。

如果我们将输入变平并分成该长度的块，则会得到输出矩阵的所有行，尽管顺序错误。对于我们的示例输入，这给出了

[  [1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0],
   [0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0],
   [0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]  ]

为了获得最终输出，我们必须首先将行数组拆分为等长的ℓ个块。对于我们的示例输入，这给出了

[ [[1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0]],
  [[0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0]],
  [[0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]] ]

现在，每一列都是输出矩阵之一，因此只需对结果数组矩阵进行转置即可。对于我们的示例输入，

[
 [[1, 0, 0],
  [0, 1, 0],
  [0, 0, 1]],

 [[127,  63,   31],
  [ 15,   0,  -15],
  [-31, -63, -127]],

 [[1, 0, 0],
  [0, 0, 1],
  [0, 1, 0]],

 [[0, 0, 0],
  [0, 0, 0],
  [0, 0, 0]]
]

如预期的。

怎么运行的

Fðs⁹œsZµḢḢL  Monadic link. Argument: A (ragged array)


F            Monadic chain. Argument: A

F            Flatten A. This yields the vector V.


       µḢḢL  Monadic chain. Argument: A

        Ḣ    Head; retrieve the first element of A.
         Ḣ   Head; retrieve the first element of the first element of A.
          L  Compute ℓ, the length of the resulting array.


 ðs⁹œsZ      Dyadic chain. Left argument: V. Right argument: ℓ

  s⁹         Split V into chunks of length ℓ.
    œs       Split the result into ℓ chunks of equal length.
      Z      Zip/transpose the result.

Pyth，12个字节

CcJlhhQc.nQJ

这是我的果冻答案的一部分。

在线尝试！

怎么运行的

Pyth解析程序如下（伪代码）。

C(c(J = l(h(h(Q))), c(.n(Q), J)))

Q是保存输入的变量。J是未定义的变量。

First J = l(h(h(Q)))将Q的头部的头部（第一个元素）的长度存储在J中。

然后，将Q展.n(Q)平，并将结果分成长度为J的片段。c(..., J)

然后，c(J, ...)将结果分成J个。

最后，C(...)转置结果。

Pyth，29个字节

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

测试套件。

怎么运行的

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

              z        input
             :      3  split at matches of the following regex
               "\B,"   /\B,/
            J          store at J
           U           [1,2,...,len(J)]

                           J  J
                        @R1   take the second character of each
                              substring in J
                     x\[      indices of all occurrences of "["

          -   filter away the elements in ^ from the
              elements in ^^ to find the first substring
              which does not start with "[["
         h    the first element
              note: this will generate an error if
              all substrings start with "[[", e.g. in the
              first example. We will deal with the error later.
       cJ     split J in groups of the specified length
      C       transpose                             ^
     s        flatten                               |
  j\,         join with ","                         |
.x            if the above code generated an error (|), return
              the following instead:
                            z      the input

算法

让我们来处理输入[[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]。

我们将在这里使用纯字符串操作。

首先，我们在逗号（不是最深列表的一部分）处分割输入（这是通过在regex处分割\B,）：

[[[1,0]
[[1,0]
[[0,1]
[[0,-1]
[0,1]]
[0,-1]]
[1,0]]
[1,0]]]

然后，我们找到第一个不以开头的子字符串的索引[[（这是通过检查index 1处的字符是否为来完成的[）。在这种情况下，是4因为索引4的子字符串[0,1]]不是以开头的[[。

然后，我们将子字符串分成4组，然后转置：

[[[1,0]
[0,1]]
[[1,0]
[0,-1]]
[[0,1]
[1,0]]
[[0,-1]
[1,0]]]

然后，我们用逗号将它们加入：

[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

的JavaScript（ES6），132个 130字节

f=(a,n=1)=>a[0][n]?a[0][n][0][0]?f(a,n+1,a[0].splice(n,1,...a[0][n])):n>1?[...Array(n)].map((_,i)=>a[0].filter((_,j)=>j%n==i)):a:a

有四种情况：

• 一个刚好返回的1×n数组（这是第一个测试，但取反了）
• 一个尚未被展平的m×n数组，我们递归地展平一个步骤，同时计数n。
• 一个已平整的m×n数组，我们在其中过滤掉每个n元素。
• 一个m×1数组，刚刚返回

05AB1E，11个字节

丹尼斯回答的港口。码：

¬¬g¹˜sô¬gäø

使用CP-1252编码。在线尝试！

Mathematica，104个字节

l=Length;(m=l@#[[1,1]];n=l@Flatten@#/m;Table[Partition[#~ArrayReshape~{n,m},n/m][[j,i]],{i,n/m},{j,m}])&

输入项

{{{1，0}，{{1，0}，{{0，1}，{{0，-1}，{0，1}}，{0，-1}}，{1，0} }，{1，0}}}

输出

{{{1，0}，{0，1}}，{{1，0}，{0，-1}}，{{0，1}，{1，0}}，{{0，-1 }，{1，0}}}

输入

{{{1，0，0}，{{127，63，31}，{{1，0，0}，{{0，0，0}，{0，1，0}，{15，0， -15}，{0、0、1}，{0、0、0}，{0、0、1}}，{-31，-63，-127}}，{0、1、0}}， {0，0，0}}}

输出

{{{1，0，0}，{0，1，0}，{0，0，1}}，{{127，63，31}，{15，0，-15}，{-31，- 63，-127}}，{{1，0，0}，{0，0，1}，{0，1，0}}，{{0，0，0}，{0，0，0}， {0，0，0}}}

{{{0}}}和{{{-1}}，{{0}}，{{1}}}也是如此

-11字节感谢Martin Ender