Als Teil seines Komprimierungsalgorithmus entrollt der JPEG-Standard eine Matrix in einen Vektor entlang von Antidiagonalen mit wechselnder Richtung:

Ihre Aufgabe ist es, den entrollten Vektor zusammen mit den Matrixdimensionen zu nehmen und die entsprechende Matrix zu rekonstruieren. Als Beispiel:

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

sollte nachgeben

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

wohingegen Dimensionen 6, 2geben würden

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

Regeln

Sie können festlegen, dass nur eine der Dimensionen als Eingabe verwendet wird. Die einzelnen Eingaben können in beliebiger Reihenfolge erfolgen. Sie können davon ausgehen, dass die Breite und Höhe für die angegebene Vektorlänge positiv und gültig sind.

Sie können davon ausgehen, dass die Vektorelemente positive ganze Zahlen kleiner als sind 10.

Sie können ein Programm oder eine Funktion schreiben, indem Sie eine Eingabe über STDIN (oder die nächstgelegene Alternative), ein Befehlszeilenargument oder ein Funktionsargument vornehmen und das Ergebnis über STDOUT (oder die nächstgelegene Alternative), einen Funktionsrückgabewert oder einen Funktionsparameter (out) ausgeben.

Der Eingabevektor kann in jedem geeigneten, eindeutigen, flachen Listen- oder Zeichenkettenformat angegeben werden.

Die Ausgabematrix kann in jedem geeigneten, eindeutigen, verschachtelten Listen- oder Zeichenfolgenformat oder als flache Liste zusammen mit beiden Matrixdimensionen vorliegen. (Oder natürlich als Matrixtyp, wenn Ihre Sprache diese hat.)

Es gelten die Standardregeln für Code-Golf .

Testfälle

Jeder Testfall hat die 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]]

Verwandte Herausforderungen

• Zickzack eine Matrix (die etwas einfachere inverse Transformation)
• Drehen Sie die Antidiagonalen

Gelee, 18 13 Bytes

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

Nimmt die Anzahl der Zeilen, die Anzahl der Spalten und eine flache Liste als separate Befehlszeilenargumente.

Mein Code ist fast identisch mit dem in der Doppelherausforderung . Die einzigen Unterschiede sind ein zusätzlicherỤ (der die Permutation der Indizes invertiert) und ein s(um die Ausgabe in ein 2D-Array aufzuteilen).

Probieren Sie es online!

MATL , 29 Bytes

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

Eingegeben wird height, width,vector durch Zeilenvorschübe getrennt.

Dadurch wird ein Teil des Codes in meiner Antwort auf die damit verbundene Herausforderung wiederverwendet .

Probieren Sie es online!

Erläuterung

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

Verwendet auch das schräge Adverb /., um wie in der J- Antwort Zickzack zu spielen von dieser Herausforderung .

Verwendung

Die Eingabe erfolgt mit dem Array auf der linken Seite und den Abmessungen [height, width]auf der rechten Seite.

   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

Erläuterung

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