時々、コードに定数行列のリストがあります：

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

これは、2つの部分からなるチャレンジの最初で簡単な部分です。これでは、すべての行列が正方形であり、同じ次元を持ち、適切に並べられていると仮定できます。2番目の部分では、これらの仮定を緩和します。

ルール

入力はネストされたリストまたはその正規の文字列表現（選択した言語で）であり、同じ形式で結果を出力する必要があります。結果には常に少なくとも1つのマトリックスが含まれ、マトリックスは1x1程度に小さくなります。行列には、絶対値が128未満の（符号付き）整数のみが含まれます。

プログラムまたは関数を作成し、入力を受け取って出力を提供する標準的な方法を使用できます。

任意のプログラミング言語を使用できますが、これらの抜け穴はデフォルトでは禁止されています。

これはcode-golfであるため、バイト単位で測定された最短の有効な回答が勝ちます。

テストケース

各テストケースには、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

オンラインでお試しください！

バックグラウンド

ほとんどのことと同じように、あなたが何をしなければならないかを理解したら、この課題はかなり簡単です。そして、最終的に、3回の削除と1回のロールバックを行った後...

まず、マトリックスの次元を把握する必要があります。これは言うよりも簡単です。最初の要素の最初の要素は最初の出力行列の最初の行であるため、その長さは正方形の出力行列の列数に等しくなります。

たとえば、入力が

[  [[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つであるため、結果の配列行列を転置するだけです。入力例では、

[
 [[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は未定義の変数です。

最初に、JJ = l(h(h(Q)))のQのヘッドのヘッド（最初の要素）の長さを格納します。

次に、.n(Q)平坦化Qは、とc(..., J)長さの断片に結果を分割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

アルゴリズム

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

その後、我々は始まらない最初のサブストリングのインデックスを見つける[[（これはインデックスの文字かどうかをチェックすることによって行われ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

4つのケースがあります。

• ちょうど戻される1×n配列（これは最初のテストですが、逆になります）
• まだ平坦化されていないm×n配列。再帰的に1ステップずつ平坦化nし、同時にカウントします。
• 平坦化されたm×n配列n。ここで、すべてのth要素を除外します。
• ちょうど返される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バイト