Dans le cadre de son algorithme de compression, le standard JPEG déroule une matrice en un vecteur le long d'antidiagonales de direction alternée:

Votre tâche consiste à prendre le vecteur déroulé avec les dimensions de la matrice et à reconstruire la matrice correspondante. Par exemple:

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

devrait céder

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

alors que les dimensions 6, 2donneraient

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

Règles

Vous pouvez choisir de ne prendre qu'une seule des dimensions en entrée. Les entrées individuelles peuvent être prises dans n'importe quel ordre. Vous pouvez supposer que la largeur et la hauteur sont positives et valables pour la longueur de vecteur donnée.

Vous pouvez supposer que les éléments vectoriels sont des entiers positifs inférieurs à 10.

Vous pouvez écrire un programme ou une fonction, en prenant une entrée via STDIN (ou l'alternative la plus proche), un argument de ligne de commande ou un argument de fonction et en sortant le résultat via STDOUT (ou l'alternative la plus proche), la valeur de retour de la fonction ou le paramètre de la fonction (out).

Le vecteur d'entrée peut être donné dans n'importe quel format de liste plate ou de chaîne pratique et sans ambiguïté.

La matrice de sortie peut être dans n'importe quel format de liste ou de chaîne imbriquée, sans ambiguïté, ou sous forme de liste plate avec les deux dimensions de la matrice. (Ou, bien sûr, comme type de matrice si votre langue en possède.)

Les règles de code-golf standard s'appliquent.

Cas de test

Chaque cas de test est de la forme 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]]

Défis liés

• Zigzagifiez une matrice (la transformation inverse un peu plus simple)
• Faites pivoter les anti-diagonales

Gelée, 18 13 octets

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

Prend le nombre de lignes, le nombre de colonnes et une liste plate comme arguments de ligne de commande séparés.

Mon code est presque identique à celui du challenge twin . Les seules différences sont un supplément Ụ(qui inverse la permutation des indices) et un s(pour diviser la sortie en un tableau 2D).

Essayez-le en ligne!

MATL , 29 octets

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

L' entrée est height, width, vectorséparés par des sauts de ligne.

Cela réutilise une partie du code dans ma réponse au défi associé .

Essayez-le en ligne!

Explication

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

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

Utilise également l'adverbe oblique /.pour effectuer la zigzagification comme dans la réponse J de ce défi .

Usage

L'entrée est avec le tableau sur le LHS et les dimensions [height, width] sur le 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

Explication

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