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]]]
fuente
[([1, 0], [0, 1]), ([1, 0], [0, -1]), ([0, 1], [1, 0]), ([0, -1], [1, 0])]
una salida válida para el tercer caso de prueba? Es una lista mixta y tupla.[([1,0], ([1, 0}, ...
y eso le daría información adicional.Respuestas:
Jalea ,
20151311 bytesPrué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
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
Para obtener el resultado final, primero debemos dividir la matriz de filas en ℓ trozos de igual longitud. Para nuestra entrada de ejemplo, esto da
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
como se desee.
Cómo funciona
fuente
Pyth , 12 bytes
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).
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 , yc(..., J)
divide el resultado en trozos de longitud J .Luego,
c(J, ...)
divide el resultado en J piezas.Finalmente,
C(...)
transpone el resultado.fuente
Pyth , 29 bytes
Banco de pruebas.
Cómo funciona
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,
):Luego, encontramos el índice de la primera subcadena que no comienza
[[
(esto se hace comprobando si el carácter en el índice1
es[
). En este caso, lo es4
, 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:
Y luego los unimos con comas:
fuente
JavaScript (ES6),
132130 bytesHay cuatro casos:
n
al mismo tiempo.n
elemento th.fuente
05AB1E , 11 bytes
Un puerto de la respuesta de Dennis . Código:
Utiliza la codificación CP-1252 . Pruébalo en línea!
fuente
Mathematica, 104 bytes
Entrada
salida
entrada
salida
{{{0}}} y {{{-1}}, {{0}}, {{1}}} también funcionan
-11 bytes gracias a Martin Ender
fuente