Lấy cảm hứng từ Sao chép từ câu hỏi này tại Stack Overflow.

Đưa ra một ma trận A, tạo một ma trận Bsao cho các cột Ađược sắp xếp theo kiểu đường chéo. Ví dụ, được đưa ra

1 2 3
4 5 6

đầu ra sẽ là

1 0 0
4 0 0
0 2 0
0 5 0
0 0 3
0 0 6

Quy tắc

Đầu vào và đầu ra có thể ở dạng mảng 2D, mảng lồng nhau hoặc chuỗi có các dấu phân cách khác nhau cho các hàng và cột.

Các số trong đầu vào (ma trận A) sẽ là các số nguyên dương.

Định dạng unary được cho phép, miễn là số không trong đầu ra được hiển thị theo một cách hợp lý. Ví dụ: kết quả trên có thể được hiển thị bằng dấu ngoặc kép để gửi kèm theo mỗi số:

'1' '' ''
'1111' '' ''
'' '11' ''
'' '11111' ''
'' '' '111'
'' '' '111111'

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

Đầu ra đầu vào:

1 2 3
4 5 6

1 0 0
4 0 0
0 2 0
0 5 0
0 0 3
0 0 6


10 20

10  0
 0 20    


10
20

10
20


  1   2   3
 10  20  30
100 200 300

  1   0   0
 10   0   0
100   0   0
  0   2   0
  0  20   0
  0 200   0
  0   0   3
  0   0  30
  0   0 300

 2  4
 6  8
10 12

 2  0
 6  0
10  0
 0  4
 0  8
 0 12

MATL , 6 byte

"@N$Yd

Hoạt động trong phiên bản hiện tại (13.0.0) của ngôn ngữ / trình biên dịch.

Đầu vào có dạng sau, với dấu chấm phẩy là dấu phân cách hàng và dấu phẩy hoặc dấu cách là dấu phân cách cột trong mỗi hàng:

[1, 2, 3; 4, 5, 6]

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

Giải trình

"         % implicitly input 2D array and loop over its columns
  @       %   push column
  N$Yd    %   build block-diagonal matrix from all stack contents. Stack contents are
          %   a single column in the first iteration, or a partially built 2D array
          %   and a new column in all other iterations
          % end loop
          % implicit display

Ví dụ làm việc

Hãy xem xét đầu vào [1 2 3; 4 5 6]. Vòng lặp for bắt đầu với "mỗi cột của đầu vào. Trong mỗi lần lặp, @đẩy cột hiện tại lên ngăn xếp. Vì vậy, trong lần lặp đầu tiên, nó đẩy [1; 4]. N$xác định rằng tất cả các nội dung ngăn xếp sẽ được sử dụng làm đầu vào của hàm sau , Yd.

Hàm này (tương ứng với MATLAB blkdiag) "nối chéo" các đầu vào của nó để tạo ra ma trận đường chéo khối (mảng 2D). Vì vậy, trong lần lặp đầu tiên, Ydnó nhận một đầu vào và tạo ra một đầu ra bằng với đầu vào [1; 4]đó, được để lại trên ngăn xếp.

Trong lần lặp thứ hai, cột thứ hai của đầu vào [2; 5], được đẩy. Bây giờ Ydcó hai 2 × 1 đầu vào, cụ thể là [1; 4]và [2; 5], và tạo ra các mảng 4 × 2 [1 0; 4 0; 0 2; 0 5].

Trong lần lặp thứ ba, Ydlấy mảng 4 × 2 sau và cột thứ ba của đầu vào [3; 6], và tạo ra kết quả cuối cùng [1 0 0; 4 0 0; 0 2 0; 0 5 0; 0 0 3; 0 0 6].

ES6, 65 byte

a=>[].concat(...a[0].map((_,i)=>a.map(b=>b.map((c,j)=>i-j?0:c))))

Lấy làm đầu vào và trả về như đầu ra một mảng các mảng.

Toán học, 40 39 byte

Tín dụng cho @Seeq cho Infixing Flatten.

Transpose[DiagonalMatrix/@#]~Flatten~1&

Đầu vào là danh sách các vectơ hàng được phân định bằng {}dấu ngoặc. Vì vậy, ví dụ ban đầu được đại diện bởi

{{1,2,3},{4,5,6}}

Tạo một mảng trong DiagonalMatrixđó mỗi cái có các phần tử đường chéo từ các hàng của đầu vào (mảng 3-D). Transposedo đó, Flattenhoạt động loại bỏ các cặp khung chính xác để đưa ra ma trận mong muốn (bây giờ là mảng 2 chiều).

Bình thường, 17

s.em.>+dm0thQkbCQ

Dùng thử trực tuyến hoặc chạy Test Suite .

Bạn có thể thêm một đầu jđể giúp trực quan hóa mảng 2D.

Thạch, 13 byte

ZLR’×L0ẋ;"Zz0

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

Làm thế nào nó hoạt động

ZLR’×L0ẋ;"Zz0  Main link. Input: M (matrix)

Z              Transpose M.
 L             Get the length of the result. This yields the number of M's columns.
  R            Range; for m columns, yield [1, ..., m].
   ’           Decrement to yield [0, ..., m-1].
    ×L         Multiply each by the length (number of rows) of M.
               This yields [0, n, ..., n(m-1)], where n is the number of rows.
      0ẋ       Push a list of lists of zeroes.
               First element is [], last is n(m-1) zeroes.
        ;"Z    Prepend the kth vector of zeroes to the kth column of M.
           z0  Zip, filling the non-rectangular 2D array with zeroes.

Toán học, 111 byte

Join@@@ReplacePart[Table[0,#2/#3]~Table~#3~Table~#3,Table[{n,n}->#[[n]],{n,#3}]]&[Length@#,Length@Flatten@#,#]&

Ruby, 81 78 76 62 byte

->a{i=-1;a[0].flat_map{i+=1;a.map{|b|x=b.map{0};x[i]=b[i];x}}}

thở dài Theo dõi chỉ số bằng tay ngắn hơn with_index.

->a{
i=-1;            # index of the flat_map
a[0]             # duplicate all rows as many times as necessary
.flat_map{       # we're wrapping each "group" of original rows with yet another
                 #  array, so we need to flat_map to get rid of those
i+=1;            # increment the index of the current subarray
a.map{|b|        # for each sub-subarray (these are the rows)...
x=b.map{0};      # zero everything out
x[i]=b[i];       # replace the desired elements
x}}}             # finally, return the modified array

R, 41 byte

pryr::f(Matrix::.bdiag(plyr::alply(a,2)))

Giả định pryr, Matrixvà plyrcác gói được cài đặt.

Điều này tạo ra một hàm lấy một mảng 2D (a) và trả về một "spzzyMatrix" trong đó (trong đó 0 được biểu diễn dưới dạng .)

(a=matrix(1:6,ncol=3))
#      [,1] [,2] [,3]
# [1,]    1    3    5
# [2,]    2    4    6
pryr::f(Matrix::.bdiag(plyr::alply(a,2)))(a)
# 6 x 3 sparse Matrix of class "dgTMatrix"
#          
# [1,] 1 . .
# [2,] 2 . .
# [3,] . 3 .
# [4,] . 4 .
# [5,] . . 5
# [6,] . . 6

Giải trình:

plyr::alply(a,2)mỗi cột avà trả về kết hợp những kết quả này trong một danh sách

Matrix::.bdiag(lst) tạo một ma trận đường chéo khối từ một danh sách các ma trận

pryr::f là một cách tốc ký để tạo ra một chức năng.

Một Rgiải pháp cơ bản đầy đủ trong 59 byte (sử dụng logic của câu trả lời Matlab của @ PieCot):

function(a){l=dim(a);diag(l[2])%x%matrix(1,nrow=l[1])*c(a)}

MATLAB, 69 68 byte

   function h=d(a)
   [r,c]=size(a);h=repmat(a,c,1).*kron(eye(c),~~(1:r)')

Một byte đã bị xóa: cảm ơn Luis Mendo :)

APL (Dyalog Classic) , 11 byte

⍉⍪⍉↑(0,⊢)\⎕

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