Là một phần của thuật toán nén của nó, tiêu chuẩn JPEG sẽ hủy một ma trận thành một vectơ dọc theo các antidiagonals theo hướng xen kẽ:

Nhiệm vụ của bạn là lấy vectơ không được kiểm soát cùng với kích thước ma trận và xây dựng lại ma trận tương ứng. Ví dụ:

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

nên nhường

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

trong khi kích thước 6, 2sẽ cho

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

Quy tắc

Bạn có thể chọn chỉ lấy một trong các kích thước làm đầu vào. Các đầu vào riêng lẻ có thể được thực hiện theo thứ tự bất kỳ. Bạn có thể giả định rằng chiều rộng và chiều cao là dương và hợp lệ cho chiều dài vectơ đã cho.

Bạn có thể giả sử rằng các phần tử vectơ là số nguyên dương nhỏ hơn 10.

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Vectơ đầu vào có thể được cung cấp trong bất kỳ định dạng chuỗi hoặc danh sách phẳng hoặc thuận tiện, rõ ràng, rõ ràng.

Ma trận đầu ra có thể ở bất kỳ định dạng chuỗi hoặc danh sách lồng nhau thuận tiện, rõ ràng, hoặc dưới dạng danh sách phẳng cùng với cả hai kích thước ma trận. (Hoặc, tất nhiên, là một loại ma trận nếu ngôn ngữ của bạn có những thứ đó.)

Luật golf tiêu chuẩn được áp dụng.

Các trường hợp thử nghiệm

Mỗi trường hợp thử nghiệm có dạng 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]]

Những thách thức liên quan

• Zigzagify a Matrix (phép biến đổi nghịch đảo có phần đơn giản hơn)
• Xoay các đường chéo

Thạch, 18 13 byte

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

Lấy số lượng hàng, số cột và danh sách phẳng dưới dạng đối số dòng lệnh riêng biệt.

Mã của tôi gần giống với mã trong thử thách sinh đôi . Sự khác biệt duy nhất là một bổ sung Ụ(đảo ngược hoán vị của các chỉ số) và một s(để phân tách đầu ra thành một mảng 2D).

Hãy thử trực tuyến!

MATL , 29 byte

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

Đầu vào được height, width, vectorngăn cách bởi dòng mới.

Điều này sử dụng lại một phần của mã trong câu trả lời của tôi cho thách thức liên quan .

Hãy thử trực tuyến!

Giải trình

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

Cũng sử dụng trạng từ xiên /. để thực hiện zigzagify như trong câu trả lời J từ thử thách đó .

Sử dụng

Đầu vào là với mảng trên LHS và kích thước [height, width]trên 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

Giải trình

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