Come parte del suo algoritmo di compressione, lo standard JPEG srotola una matrice in un vettore lungo antidiagonali di direzione alternata:

Il tuo compito è prendere il vettore srotolato insieme alle dimensioni della matrice e ricostruire la matrice corrispondente. Come esempio:

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

dovrebbe cedere

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

mentre le dimensioni 6, 2darebbero

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

Regole

Puoi scegliere di prendere solo una delle dimensioni come input. I singoli ingressi possono essere presi in qualsiasi ordine. Si può presumere che la larghezza e l'altezza siano positive e valide per la lunghezza del vettore indicata.

Si può presumere che gli elementi vettoriali siano numeri interi positivi inferiori a 10.

È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e producendo il risultato tramite STDOUT (o l'alternativa più vicina), il valore di ritorno della funzione o il parametro della funzione (out).

Il vettore di input può essere fornito in qualsiasi elenco o formato stringa conveniente, inequivocabile.

La matrice di output può essere in qualsiasi elenco o formato stringa nidificato conveniente, inequivocabile o come elenco semplice con entrambe le dimensioni della matrice. (O, ovviamente, come tipo di matrice se la tua lingua ne ha.)

Si applicano le regole standard del code-golf .

Casi test

Ogni caso di test ha la forma 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]]

Sfide correlate

• Zigzagify a Matrix (la trasformazione inversa un po 'più semplice)
• Ruota le anti-diagonali

Gelatina, 18 13 byte

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

Accetta il numero di righe, il numero di colonne e un elenco semplice come argomenti della riga di comando separati.

Il mio codice è quasi identico a quello della sfida gemella . Le uniche differenze sono un ulteriore Ụ(che inverte la permutazione degli indici) e un s(per dividere l'output in un array 2D).

Provalo online!

MATL , 29 byte

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

Ingresso è height, width, vectorseparati da capo.

Questo riutilizza parte del codice nella mia risposta alla sfida correlata .

Provalo online!

Spiegazione

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

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

Utilizza anche l'avverbio obliquo /.per eseguire lo zigzagify come nella risposta J di quella sfida .

uso

L'ingresso è con l'array sull'LHS e le dimensioni [height, width]sull'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

Spiegazione

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