A veces, tengo listas de matrices constantes en mi código:

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

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

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

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

Ese es un uso terrible de la pantalla de bienes raíces. Prefiero escribirlos uno al lado del otro:

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

Encontrará que esta sigue siendo una lista anidada sintácticamente válida, ya no es rectangular y tiene una estructura muy diferente (en particular, se vuelve más profunda cada vez que agrego una matriz más grande que 1x1). Sin embargo, todavía es posible reconstruir la lista inicial de matrices a partir de esta nueva lista.

Para poder usar esta sintaxis en el futuro, necesito que escriba un código que convierta las matrices que se escribieron en una disposición horizontal en la lista de matrices que representan.

Para asegurarse de que las respuestas no realicen la coincidencia de patrones 2D en el diseño en el código fuente, la entrada se proporcionará solo como el objeto de matriz, o si toma una representación de cadena, entonces no contendrá ningún espacio en blanco que indique cómo literal fue escrito en el código. Entonces obtendría alguna entrada como esta:

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

Y la salida debe ser la siguiente matriz o su representación de cadena (nuevamente, no se necesita más diseño):

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

Esta es la primera y más fácil parte de un desafío de dos partes. En este caso, puede suponer que todas las matrices son cuadradas y tienen las mismas dimensiones y que están correctamente alineadas una al lado de la otra. En la segunda parte, relajaremos estos supuestos.

Reglas

La entrada será una lista anidada o su representación de cadena canónica (en el idioma que elija), y debe generar el resultado en el mismo formato. El resultado siempre contendrá al menos una matriz, y las matrices pueden ser tan pequeñas como 1x1. Las matrices solo contendrán enteros (con signo) con un valor absoluto inferior a 128.

Puede escribir un programa o una función y utilizar cualquiera de los métodos estándar para recibir entradas y proporcionar salidas.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Casos de prueba

Cada caso de prueba tiene a) la lista de matrices bien dispuestas una al lado de la otra como lo estarían en el código (esta no es su entrada), b) la lista sin formato sin el espacio en blanco extraño ( esta es su entrada), c) el Rendimiento esperado.

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

Jalea , 20 15 13 11 bytes

Fðs⁹œsZµḢḢL

Pruébalo en línea!

Fondo

Como la mayoría de las cosas, este desafío es bastante simple una vez que has descubierto lo que tienes que hacer. Y finalmente lo hice, después de tres eliminaciones y una reversión ...

Primero, debemos calcular las dimensiones de las matrices. Eso es más fácil de hacer que lo dicho: el primer elemento del primer elemento es la primera fila de la primera matriz de salida, por lo que su longitud es igual al número de columnas de las matrices de salida cuadradas.

Por ejemplo, si la entrada es

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

El primer elemento del primer elemento es [1, 0, 0], cuya longitud es ℓ = 3 .

Si aplanamos la entrada y la dividimos en trozos de esa longitud, obtenemos todas las filas de las matrices de salida, aunque en el orden incorrecto. Para nuestra entrada de ejemplo, esto da

[  [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 obtener el resultado final, primero debemos dividir la matriz de filas en ℓ trozos de igual longitud. Para nuestra entrada de ejemplo, esto da

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

Cada columna es ahora una de las matrices de salida, por lo que lo único que queda por hacer es transponer la matriz de matrices resultante. Para nuestra entrada de ejemplo, eso 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]]
]

como se desee.

Cómo 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.

Pyth , 12 bytes

CcJlhhQc.nQJ

Este es un puerto de mi respuesta Jelly.

Pruébalo en línea!

Cómo funciona

Pyth analiza el programa de la siguiente manera (pseudocódigo).

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

Q es una variable que contiene la entrada. J es una variable indefinida.

Primero J = l(h(h(Q)))almacena la longitud de la cabeza (primer elemento) de la cabeza de Q en J .

A continuación, .n(Q)se aplana Q , y c(..., J)divide el resultado en trozos de longitud J .

Luego, c(J, ...)divide el resultado en J piezas.

Finalmente, C(...)transpone el resultado.

Pyth , 29 bytes

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

Banco de pruebas.

Cómo 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

Trabajemos en la entrada [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]].

Usaremos operaciones de cadena pura aquí.

En primer lugar, dividimos la entrada en las comas que no forman parte de la lista más profunda (esto se hace dividiendo en la expresión regular \B,):

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

Luego, encontramos el índice de la primera subcadena que no comienza [[(esto se hace comprobando si el carácter en el índice 1es [). En este caso, lo es 4, porque la subcadena en el índice 4 es con la [0,1]]que no comienza [[.

Luego, agrupamos las subcadenas en grupos de 4, y luego transponemos:

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

Y luego los unimos con comas:

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

Hay cuatro casos:

• Una matriz de 1 × n, que acaba de ser devuelta (esta es la primera prueba, pero invertida)
• Una matriz m × n que aún no se ha aplanado, que aplanamos recursivamente en un paso, contando nal mismo tiempo.
• Una matriz m × n que se ha aplanado, donde filtramos cada n elemento th.
• Una matriz m × 1, que acaba de devolverse

05AB1E , 11 bytes

Un puerto de la respuesta de Dennis . Código:

¬¬g¹˜sô¬gäø

Utiliza la codificación CP-1252 . Pruébalo en línea!

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

salida

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

salida

{{{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}}} y {{{-1}}, {{0}}, {{1}}} también funcionan

-11 bytes gracias a Martin Ender