Às vezes, tenho listas de matrizes constantes no meu código:

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

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

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

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

Esse é um uso terrível do espaço da tela. Prefiro escrevê-los um ao lado do outro:

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

Você verá que essa ainda é uma lista aninhada sintaticamente válida, não é mais retangular e tem uma estrutura muito diferente (em particular, fica mais profunda a cada vez que adiciono uma matriz maior que 1x1). No entanto, ainda é possível reconstruir a lista inicial de matrizes dessa nova lista.

Para que eu possa usar essa sintaxe no futuro, preciso que você escreva algum código que converta matrizes que foram gravadas em um arranjo horizontal na lista de matrizes que elas representam.

Para garantir que as respostas não executem a correspondência de padrões 2D no layout do código-fonte, a entrada será fornecida apenas como o objeto da matriz ou, se você fizer uma representação de cadeia, ela não conterá nenhum espaço em branco indicando como o objeto literal foi escrito no código. Então você receberia uma entrada como esta:

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

E a saída deve ser a seguinte matriz ou sua representação de cadeia (novamente, nenhum layout adicional é necessário):

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

Esta é a primeira e mais fácil parte de um desafio em duas partes. Nesta, você pode assumir que todas as matrizes são quadradas e têm as mesmas dimensões e que estão alinhadas adequadamente uma à outra. Na segunda parte, relaxaremos essas suposições.

Regras

A entrada será uma lista aninhada ou sua representação de string canônica (no idioma de sua escolha) e você deverá gerar o resultado no mesmo formato. O resultado sempre conterá pelo menos uma matriz e as matrizes podem ser tão pequenas quanto 1x1. As matrizes conterão apenas números inteiros (assinados) com valor absoluto menor que 128.

Você pode escrever um programa ou uma função e usar qualquer um dos métodos padrão de recebimento de entrada e saída.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é código-golfe , então a resposta mais curta e válida - medida em bytes - vence.

Casos de teste

Cada caso de teste possui a) as matrizes da lista dispostas muito próximas umas das outras, como estariam no código (essa não é sua entrada), b) a lista não formatada sem o espaço em branco estranho ( essa é sua entrada), c) a saída esperada.

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

Geléia , 20 15 13 11 bytes

Fðs⁹œsZµḢḢL

Experimente online!

fundo

Como a maioria das coisas, esse desafio é bastante simples depois que você descobre o que precisa fazer. E acabei conseguindo, depois de três exclusões e uma reversão ...

Primeiro, devemos descobrir as dimensões das matrizes. Isso é mais fácil do que foi dito: o primeiro elemento do primeiro elemento é a primeira linha da primeira matriz de saída, portanto, seu comprimento é igual ao número de colunas das matrizes quadradas de saída.

Por exemplo, se a entrada for

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

o primeiro elemento do primeiro elemento é [1, 0, 0], cujo comprimento é ℓ = 3 .

Se nivelarmos a entrada e a dividirmos em pedaços desse comprimento, obteremos todas as linhas das matrizes de saída, embora na ordem errada. Para nosso exemplo de entrada, isso fornece

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

Para obter a saída final, devemos primeiro dividir a matriz de linhas em ℓ pedaços de comprimento igual. Para nosso exemplo de entrada, isso fornece

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

Agora, cada coluna é uma das matrizes de saída; portanto, basta transpor a matriz de matrizes resultante. Para nosso exemplo de entrada, isso fornece

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

como desejado.

Como funciona

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.

Pitão , 12 bytes

CcJlhhQc.nQJ

Esta é uma porta da minha resposta Jelly.

Experimente online!

Como funciona

Pyth analisa o programa da seguinte maneira (pseudo-código).

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

Q é uma variável que mantém a entrada. J é uma variável indefinida.

Primeira J = l(h(h(Q)))armazena o comprimento da cabeça (primeiro elemento) da cabeça de Q em J .

Em seguida, .n(Q)achata Q , e c(..., J)divide o resultado em pedaços de comprimento J .

Depois, c(J, ...)divide o resultado em J pedaços.

Por fim, C(...)transpõe o resultado.

Pitão , 29 bytes

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

Suíte de teste.

Como funciona

.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

Algoritmo

Vamos trabalhar na entrada [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

Usaremos operações de cadeia pura aqui.

Primeiramente, dividimos a entrada nas vírgulas que não fazem parte da lista mais profunda (isso é feito dividindo-se na regex \B,):

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

Em seguida, encontramos o índice da primeira substring que não inicia [[(isso é feito verificando se o caractere no índice 1é [). Nesse caso, é 4porque a substring no índice 4 é a [0,1]]que não inicia [[.

Em seguida, agrupamos as substrings em grupos de 4 e depois transpomos:

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

E então nos juntamos a eles com vírgulas:

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

JavaScript (ES6), 132 130 bytes

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

Existem quatro casos:

• Uma matriz 1 × n, que acabou de ser retornada (este é o primeiro teste, mas invertido)
• Uma matriz m × n que ainda não foi achatada, que achatamos recursivamente uma etapa, contando nao mesmo tempo.
• Uma matriz m × n que foi achatada, onde filtramos cada nelemento th.
• Uma matriz m × 1, que é retornada

05AB1E , 11 bytes

Um porto da resposta de Dennis . Código:

¬¬g¹˜sô¬gäø

Usa a codificação CP-1252 . Experimente online!

Mathematica, 104 bytes

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

Entrada

{{{1, 0}, {{1, 0}, {{0, 1}, {{0, -1}, {0, 1}}, {0, -1}}, {1, 0} }, {1, 0}}}

saída

{{{1, 0}, {0, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{0, -1 }, {1, 0}}}

entrada

{{{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}}}

saída

{{{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}}} e {{{-1}}, {{0}}, {{1}}} também funcionam

-11 bytes graças a Martin Ender