Como parte de seu algoritmo de compactação, o padrão JPEG desenrola uma matriz em um vetor ao longo de antidiagonais de direção alternada:

Sua tarefa é pegar o vetor desenrolado junto com as dimensões da matriz e reconstruir a matriz correspondente. Como um exemplo:

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

deve render

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

considerando que as dimensões 6, 2dariam

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

Regras

Você pode optar por usar apenas uma das dimensões como entrada. As entradas individuais podem ser obtidas em qualquer ordem. Você pode assumir que a largura e a altura são positivas e válidas para o comprimento do vetor especificado.

Você pode assumir que os elementos do vetor são inteiros positivos menores que 10.

Você pode escrever um programa ou função, recebendo entrada via STDIN (ou alternativa mais próxima), argumento da linha de comando ou argumento da função e emitindo o resultado via STDOUT (ou alternativa mais próxima), valor de retorno da função ou parâmetro da função (saída).

O vetor de entrada pode ser fornecido em qualquer formato conveniente, inequívoco, de lista ou cadeia simples.

A matriz de saída pode estar em qualquer formato conveniente de lista ou seqüência aninhada, inequívoca, ou como uma lista simples junto com as duas dimensões da matriz. (Ou, é claro, como um tipo de matriz, se o seu idioma tiver esse.)

Aplicam-se as regras de código-golfe padrão .

Casos de teste

Cada caso de teste é do formato 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]]

Desafios relacionados

• Ziguezague uma matriz (a transformação inversa um pouco mais simples)
• Gire as antiagonais

Geléia, 18 13 bytes

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

Leva o número de linhas, o número de colunas e uma lista simples como argumentos separados da linha de comando.

Meu código é quase idêntico ao do desafio duplo . As únicas diferenças são uma adicional Ụ(que inverte a permutação dos índices) e uma s(para dividir a saída em uma matriz 2D).

Experimente online!

MATL , 29 bytes

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

A entrada é height, width, vectorseparadas por novas linhas.

Isso reutiliza parte do código na minha resposta ao desafio relacionado .

Experimente online!

Explicação

:!      % 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.)

Também usa o advérbio oblíquo /.para executar ziguezague como na resposta J desse desafio .

Uso

A entrada é com a matriz no LHS e as dimensões [height, width]no 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

Explicação

]$({~[:/:@;[:<@|.`</.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