W ramach algorytmu kompresji standard JPEG rozwija matrycę do wektora wzdłuż przeciwbieżnych zmiennych kierunków:

Twoim zadaniem jest pobranie rozwiniętego wektora wraz z wymiarami macierzy i odtworzenie odpowiedniej macierzy. Jako przykład:

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

powinien ustąpić

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

podczas gdy wymiary 6, 2dawałyby

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

Zasady

Możesz wybrać tylko jeden z wymiarów jako dane wejściowe. Poszczególne dane wejściowe można przyjmować w dowolnej kolejności. Możesz założyć, że szerokość i wysokość są dodatnie i prawidłowe dla podanej długości wektora.

Możesz założyć, że elementy wektorowe są dodatnimi liczbami całkowitymi mniejszymi niż 10 .

Możesz napisać program lub funkcję, pobierając dane wejściowe przez STDIN (lub najbliższą alternatywę), argument wiersza poleceń lub argument funkcji i wypisując wynik przez STDOUT (lub najbliższą alternatywę), wartość zwracaną funkcji lub parametr funkcji (wyjściowej).

Wektor wejściowy może być podany w dowolnym wygodnym, jednoznacznym, płaskim formacie lub w postaci łańcucha.

Macierz wyjściowa może być w dowolnym dogodnym, jednoznacznym, zagnieżdżonym formacie listy lub ciągu znaków, lub jako płaska lista wraz z oboma wymiarami macierzy. (Lub, oczywiście, jako typ matrycy, jeśli Twój język je ma.)

Standardowy golf zasady .

Przypadki testowe

Każdy przypadek testowy ma formę 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]]

Powiązane wyzwania

• Zigzagify a Matrix (nieco prostsza transformacja odwrotna)
• Obróć anty-przekątne

Galaretka, 18 13 bajtów

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

Pobiera liczbę wierszy, liczbę kolumn i płaską listę jako osobne argumenty wiersza polecenia.

Mój kod jest prawie identyczny z tym z podwójnego wyzwania . Jedyne różnice to dodatkowy Ụ(który odwraca permutację indeksów) i s(aby podzielić dane wyjściowe na tablicę 2D).

Wypróbuj online!

MATL , 29 bajtów

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

Wejście jest height, width,vector oddzielone znakami nowej linii.

To ponownie wykorzystuje część kodu w mojej odpowiedzi na powiązane wyzwanie .

Wypróbuj online!

Wyjaśnienie

:!      % 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 bajty

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

Używa również skośnego przysłówka, /.aby wykonać zygzak, jak w odpowiedzi J z tego wyzwania .

Stosowanie

Dane wejściowe są z tablicą na LHS i wymiarami [height, width]na 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

Wyjaśnienie

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