때로는 코드에 상수 행렬 목록이 있습니다.

[ [[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보다 작은 (부호있는) 정수만 포함됩니다.

사용자가 쓸 수 프로그램이나 함수를 상기의 어떠한 사용도 표준 방법 의 입력을 수신하고 출력을 제공한다.

모든 프로그래밍 언어를 사용할 수 있지만 이러한 허점 은 기본적으로 금지되어 있습니다.

이것은 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

온라인으로 사용해보십시오!

배경

대부분의 일과 마찬가지로이 과제는 수행해야 할 작업을 파악한 후에는 간단합니다. 그리고 세 번의 삭제와 한 번의 롤백 후에 결국에 ...

먼저 행렬의 크기를 알아 내야합니다. 첫 번째 요소의 첫 번째 요소는 첫 번째 출력 행렬의 첫 번째 행이므로 길이는 제곱 출력 행렬의 열 수와 같습니다.

예를 들어 입력이

[  [[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 는 정의되지 않은 변수입니다.

먼저 J = l(h(h(Q)))머리의 점포 헤드 (제 1 요소)의 길이 Q 의 J .

이어서, .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

연산

입력 작업을 해보자 [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

여기서는 순수한 문자열 연산을 사용할 것입니다.

먼저 가장 깊은 목록에 속하지 않는 쉼표로 입력을 분할합니다 (정규 표현식에서 분할하여 수행함 \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]]]

자바 스크립트 (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

네 가지 경우가 있습니다.

• 1xn 배열로 방금 반환됩니다 (첫 번째 테스트이지만 반전 됨).
• 아직 평탄화되지 않은 m × n 배열, 우리는 한 단계 씩 재귀 적으로 평탄화 n하면서 동시에 계산 합니다.
• 평평해진 m × n 배열로 모든 n원소를 걸러냅니다 .
• 방금 반환 된 m × 1 배열

05AB1E , 11 바이트

Dennis 의 답변 포트 . 암호:

¬¬g¹˜sô¬gäø

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

수학, 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}}}도 작동

Martin Ender 덕분에 -11 바이트