Como parte de su algoritmo de compresión, el estándar JPEG desenrolla una matriz en un vector a lo largo de antidiagonales de dirección alterna:

Su tarea es tomar el vector desenrollado junto con las dimensiones de la matriz y reconstruir la matriz correspondiente. Como ejemplo:

[1, 2, 5, 9, 6, 3, 4, 7, 1, 2, 8, 3], 4, 3

debería rendir

[1 2 3 4
 5 6 7 8
 9 1 2 3]

mientras que las dimensiones 6, 2 darían

[1 2 6 3 1 2
 5 9 4 7 8 3]

Reglas

Puede elegir tomar solo una de las dimensiones como entrada. Las entradas individuales se pueden tomar en cualquier orden. Puede suponer que el ancho y la altura son positivos y válidos para la longitud del vector dado.

Puede suponer que los elementos del vector son enteros positivos menores que 10 .

Puede escribir un programa o función, tomando la entrada a través de STDIN (o la alternativa más cercana), argumento de línea de comando o argumento de función y generando el resultado a través de STDOUT (o la alternativa más cercana), el valor de retorno de la función o el parámetro de función (out).

El vector de entrada se puede dar en cualquier formato conveniente, sin ambigüedades, de lista plana o de cadena.

La matriz de salida puede estar en cualquier lista conveniente o inequívoca, anidada o formato de cadena, o como una lista plana junto con ambas dimensiones de la matriz. (O, por supuesto, como un tipo de matriz si su idioma los tiene).

Aplican reglas estándar de código de golf .

Casos de prueba

Cada caso de prueba es de la forma vector width height => matrix.

[1] 1 1                        => [[1]]
[1 2 3 1] 2 2                  => [[1 2] [3 1]]
[1 2 3 1] 4 1                  => [[1 2 3 1]]
[1 2 5 9 6 3 4 7 1 2 8 3] 3 4  => [[1 2 3] [5 6 4] [9 7 8] [1 2 3]]
[1 2 5 9 6 3 4 7 1 2 8 3] 4 3  => [[1 2 3 4] [5 6 7 8] [9 1 2 3]]
[1 2 5 9 6 3 4 7 1 2 8 3] 6 2  => [[1 2 6 3 1 2] [5 9 4 7 8 3]]
[1 2 5 9 6 3 4 7 1 2 8 3] 12 1 => [[1 2 5 9 6 3 4 7 1 2 8 3]]
[1 2 5 9 6 3 4 7 1 2 8 3] 1 12 => [[1] [2] [5] [9] [6] [3] [4] [7] [1] [2] [8] [3]]

Desafíos relacionados

• Zigzagificar una matriz (la transformación inversa algo más simple)
• Rotar las antiagoniales

Jalea, 18 13 bytes

pS€żị"¥pỤỤị⁵s

Toma el número de filas, el número de columnas y una lista plana como argumentos separados de la línea de comandos.

Mi código es casi idéntico al del desafío doble . Las únicas diferencias son un adicional Ụ(que invierte la permutación de los índices) y un s(para dividir la salida en una matriz 2D).

Pruébalo en línea!

MATL , 29 bytes

:!i:+-1y^8MtsQ/*-X:4#S2$S1GZC

La entrada es height, width, vectorseparados por saltos de línea.

Esto reutiliza parte del código en mi respuesta al desafío relacionado .

Pruébalo en línea!

Explicación

:!      % take number of rows, r, as input. Generate column vector [1;2;...;r]
i:      % take number of columns, c, as input. Generate row vector [1,2,...,c] 
+       % add with broadcast. Gives 2D array
-1      % push -1
y^      % duplicate previous 2D array. Compute -1 raised to that
8M      % push [1;2;...;r] again
tsQ/    % divide by its sum plus 1
*       % multiply
-       % subtract
X:      % linearize 2D array into column array
4#S     % sort and push the indices of the sorting. Gives a column vector
2$S     % take vector as input. Sort it according to previous column vector
1G      % push r
ZC      % reshape into columns of r elements

J, 24 bytes

]$({~[:/:@;[:<@|.`</.i.)

También usa el adverbio oblicuo /.para realizar zigzagify como en la respuesta J de ese desafío .

Uso

La entrada es con la matriz en el LHS y las dimensiones [height, width]en el RHS.

   f =: ]$({~[:/:@;[:<@|.`</.i.)
   1 f 1 1
1
   1 2 3 1 f 2 2
1 2
3 1
   1 2 5 9 6 3 4 7 1 2 8 3 f 4 3
1 2 3
5 6 4
9 7 8
1 2 3
   1 2 5 9 6 3 4 7 1 2 8 3 f 3 4
1 2 3 4
5 6 7 8
9 1 2 3
   1 2 5 9 6 3 4 7 1 2 8 3 f 2 6
1 2 6 3 1 2
5 9 4 7 8 3
   1 2 5 9 6 3 4 7 1 2 8 3 f 1 12
1 2 5 9 6 3 4 7 1 2 8 3
   1 2 5 9 6 3 4 7 1 2 8 3 f 12 1
1
2
5
9
6
3
4
7
1
2
8
3

Explicación

]$({~[:/:@;[:<@|.`</.i.)  Input: list A (LHS), dimensions D (RHS)
                     i.   Range shaped to D
           [:<@|.`</.     Zigzagify that matrix
     [:   ;               Raze the boxes to get a zigzagify permutation
       /:@                Invert that permutation to get an unzigzagify permutation
   {~                     Apply that permutation to A
]                         Get D
 $                        Shape that permutation to D and return