В рамках алгоритма сжатия стандарт JPEG разворачивает матрицу в вектор вдоль антидиагоналей переменного направления:

Ваша задача - взять развернутый вектор вместе с размерами матрицы и восстановить соответствующую матрицу. В качестве примера:

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

тогда как размеры 6, 2дадут

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

правила

Вы можете выбрать в качестве входных данных только одно из измерений. Индивидуальные входы могут быть приняты в любом порядке. Вы можете предположить, что ширина и высота положительны и действительны для данной длины вектора.

Вы можете предположить, что элементы вектора имеют положительные целые числа меньше, чем 10.

Вы можете написать программу или функцию, принимая ввод через STDIN (или ближайшую альтернативу), аргумент командной строки или аргумент функции и выводя результат через STDOUT (или ближайшую альтернативу), возвращаемое значение функции или параметр функции (out).

Входной вектор может быть задан в любом удобном, однозначном, плоском списке или строковом формате.

Выходная матрица может быть в любом удобном, однозначном, вложенном списке или формате строки или в виде плоского списка вместе с обоими размерами матрицы. (Или, конечно, как матричный тип, если ваш язык имеет такие.)

Применяются стандартные правила игры в гольф .

Тестовые случаи

Каждый тестовый пример имеет форму 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]]

Связанные проблемы

• Зигзагообразная матрица (несколько более простое обратное преобразование)
• Поверните анти-диагонали

Желе, 18 13 байтов

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

Принимает количество строк, количество столбцов и плоский список в качестве отдельных аргументов командной строки.

Мой код почти идентичен тому, что в двойном вызове . Единственными отличиями являются дополнительные Ụ(которые инвертируют перестановку индексов) и an s(для разделения выходных данных в двумерный массив).

Попробуйте онлайн!

MATL , 29 байт

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

Ввод height, width, vectorразделенные символами новой строки.

Это повторно использует часть кода в моем ответе на связанную проблему .

Попробуйте онлайн!

объяснение

:!      % 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 байта

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

Также использует наклонное наречие /.для зигзагификации, как в ответе J от этой задачи .

использование

Ввод осуществляется с помощью массива на LHS и размеров [height, width]на 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

объяснение

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