Lấy một mảng không lồng nhau làm đầu vào. Biến nó thành một ma trận bằng cách sử dụng phương pháp sau:

Hãy nói mảng của tôi là [1, 2, 3, 4, 5]

Đầu tiên, tôi lặp lại mảng đó 5 lần: (độ dài)

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

Sau đó, tôi đọc nó dọc theo các đường chéo:

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

Tôi làm phẳng mảng này và chia nó thành từng mảnh năm (chiều dài):

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

Đây là mã golf. Ít byte nhất sẽ thắng.

05AB1E, 13 byte

.p¹.sR¦«í˜¹gä

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

Giải trình:

                # Implicit input
 .p             # Get prefixes
   ¹            # Get first input
    .s          # Get suffixes
      R         # Reverse
       ¦        # Remove first element
        «       # Concatenate
         í      # Reverse every one
          ˜     # Flatten
           ¹gä  # Split into pieces of the length
                # Implicit print

Thạch , 11 byte

WẋLŒDUṙLFsL

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

Giải trình

               Input: array z
WẋL            length(z) copies of z
   ŒD          Diagonals (starting with main diagonal)
     U         Reverse each
      ṙL       Rotate left length(z) places
               (now the top-left diagonal is in front)
        F      Flatten
         sL    Split into chunks of size length(z)

Python 2, 105 96 byte

-1 và -4 và -4 byte nhờ Flp.Tkc

a=input()
n=len(a)
L,M=[],[]
for i in range(n):L+=a[i::-1];M+=a[:i:-1]
print zip(*[iter(L+M)]*n)

Vòng lặp for thêm các mục như trong mô tả, phép thuật thực sự xảy ra trong mã zip từ đây

JavaScript (ES6) 100 101 105

a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

Ít chơi gôn

a => {
  u = 0
  for(r=[], i=l=a.length; i+l>0; i--)
    for(j=l; j--; )
    {
      v = a[j-i]
      if (v) 
      {
        u %= l
        if (u==0) r.push(s=[])
        s[u++] = v
      }
    }
  return r
}

Kiểm tra

F=
a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

function update() {
  var a=I.value.match(/\d+/g)
  if (a) {
    var r=F(a)
    O.textContent = r.join`\n`
  }
}

update()

<input id=I value='1 2 3 4 5' oninput='update()'>
<pre id=O></pre>

MATL , 17 byte

!Gg*tRwZRhPXzGne!

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

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

Giải thích sau đây sử dụng đầu vào [1 2 3 4 5]làm ví dụ. Để hình dung các kết quả trung gian, chèn% (ký hiệu nhận xét) sau bất kỳ câu lệnh nào trong mã.

Lưu ý rằng đó ;là dấu phân cách hàng cho ma trận. Vậy [1 2]là một vectơ hàng, [1; 2]là một vectơ cột và [1 0; 0 1]là ma trận nhận dạng 2 × 2.

!     % Implicitly input a row vector. Transpose. Gives a column vector
      % STACK: [1; 2; 3; 4; 5]
Gg    % Push input with all (nonzero) values replaced by ones
      % STACK: [1; 2; 3; 4; 5], [1 1 1 1 1]
*     % Multiply, with broadcast. Gives a square matrix
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5]
tR    % Duplicate. Upper triangular part
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5],
               [1 1 1 1 1
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5]
wZR   % Swap. Lower triangular part, below main diagonal 
      % STACK: [1 1 1 1 1;
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5],
               [0 0 0 0 0;
                2 0 0 0 0;
                3 3 0 0 0;
                4 4 4 0 0;
                5 5 5 5 0]
h     % Concatenate horizontally
      % STACK: [1 1 1 1 1 0 0 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 0 0 5 5 5 5 5 0]
P     % Flip vertically
      % STACK: [0 0 0 0 5 5 5 5 5 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                1 1 1 1 1 0 0 0 0 0]
Xz    % Column vector of nonzeros, taken in column-major order
      % STACK: [1;2;1;3;2;1;4;3;2;1;5;4;3;2;1;5;4;3;2;5;4;3;5;4;5]
Gne   % Reshape into a matrix with as many rows as input size
      % STACK: [1 1 5 5 4;
                2 4 4 4 3;
                1 3 3 3 5;
                3 2 2 2 4;
                2 1 1 5 5]
 !    % Transpose. Implicitly display
      % STACK: [1 2 1 3 2;
                1 4 3 2 1;
                5 4 3 2 1;
                5 4 3 2 5;
                4 3 5 4 5]

JavaScript (ES6), 116 byte

a=>a.map(_=>b.splice(0,a.length),b=[].concat(...a.map((_,i)=>a.slice(~i)),...a.map((_,i)=>a.slice(0,~i))).reverse())

Chà, đó là một khởi đầu ...

R, 84 byte

t(matrix(unlist(split(m<-t(matrix(rev(x<-scan()),l<-sum(1|x),l)),row(m)-col(m))),l))

Đọc đầu vào từ stdin và đầu ra / trả về ma trận R.

reversed_x <- rev(x<-scan())                # Read input from stdin and reverse
m <- t(matrix(reversed_x,l<-sum(1|x),l))    # Repeat and fit into matrix
diag_list <- split(m,row(m)-col(m))         # Split into ragged list of diagonals
t(matrix(unlist(diag_list),l))              # Flatten and transform back to matrix

Giải thích

Khía cạnh thú vị nhất về câu trả lời này là cách lấy các đường chéo. Nói chung, một đối tượng có thể được phân tách bằng cách sử dụng splithàm nếu được cung cấp một đối tượng có chứa các yếu tố mà đối tượng được chia thành. Để tạo các yếu tố này, chúng ta có thể sử dụng colvà rowtrả về một ma trận chứa các chỉ số cột và hàng tương ứng. Bằng cách lấy sự khác biệt: row(m)-col(m)chúng ta có được một ma trận như:

     [,1] [,2] [,3] [,4] [,5]
[1,]    0   -1   -2   -3   -4
[2,]    1    0   -1   -2   -3
[3,]    2    1    0   -1   -2
[4,]    3    2    1    0   -1
[5,]    4    3    2    1    0

trong đó mỗi đường chéo được xác định duy nhất. Bây giờ chúng ta có thể phân tách dựa trên ma trận này và biến nó thành một danh sách rách rưới bằng cách áp dụng split:

$`-4`
[1] 1
$`-3`
[1] 2 1 
$`-2`
[1] 3 2 1
$`-1`
[1] 4 3 2 1
$`0`
[1] 5 4 3 2 1
$`1`
[1] 5 4 3 2
$`2`
[1] 5 4 3
$`3`
[1] 5 4
$`4`
[1] 5

(Lưu ý cách tên của mỗi vectơ tương ứng với các giá trị đường chéo trong ma trận trên).

Bước cuối cùng chỉ là làm phẳng và biến nó thành một ma trận có dạng:

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

Toán học 93 byte

Partition[Flatten[Table[If[i>n,#[[n;;(i-n+1);;-1]],#[[i;;1;;-1]]],{i,1,2(n=Length@#)-1}]],n]&

Đây là cách tôi thường viết mã này (109 Byte):

Partition[Reverse@Flatten[Table[Reverse@Diagonal[ConstantArray[Reverse@#,n],k],{k,-(n=Length@#)+1,n-1}]],n]&

Biểu đồ ma trận này đưa ra một ý tưởng tốt từ cấu trúc do một vectơ đầu vào tăng dần.

Đây là biểu đồ ma trận với một vectơ đầu vào ngẫu nhiên. Rõ ràng một số cấu trúc vẫn tồn tại.

Toán học, 92 byte

n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&;{Most@r[#~n~Rest],#~n~Most}~ArrayReshape~{l,l}&

Hàm không tên lấy một danh sách làm đối số của nó. Có thể có các cấu trúc khác cho chức năng như vậy, nhưng hy vọng tôi đã chơi cấu trúc này khá tốt ....

Phần đầu tiên n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&xác định hàm ncủa hai đối số: phần thứ nhất là danh sách độ dài lvà phần thứ hai là hàm để áp dụng cho danh sách. náp dụng l-1thời gian hàm đó cho danh sách đối số đảo ngược, lưu tất cả các kết quả trong danh sách đầu ra của nó. (Xác định rvà ltrên đường đi chỉ là chơi gôn.)

nđược gọi hai lần trong danh sách gốc, một lần với hàm là Rest(bỏ phần tử đầu tiên của danh sách) và một lần với hàm là Most(bỏ phần tử cuối cùng). Điều này tạo ra tất cả các danh sách con mong muốn, nhưng toàn bộ danh sách có hai lần (do đó là thêm Most) và nửa đầu là ở đó theo thứ tự ngược (do đó r[...]). Cuối cùng, ~ArrayReshape~{l,l}quên cấu trúc danh sách hiện tại và buộc nó là một mảng lx l.

Toán học, 85 byte

Thực hiện theo các bước được đề xuất:

(l=Length@#;Partition[Flatten@Table[Reverse@Diagonal[Table[#,l],i],{i,-l+1,l-1}],l])&

Ruột của tôi nói rằng nên có một cách thông minh để sử dụng Partđể làm điều này ngắn hơn, nhưng mọi nỗ lực tôi đã thực hiện dài hơn 85 byte.

Ruby (110 byte)

n=a.size
b=[*(0...n)]
b.product(b).group_by{|i,j|i+j}.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}.each_slice(n).to_a
  #=> [[1, 2, 1, 3, 2],
  #    [1, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 5],
  #    [4, 3, 5, 4, 5]]

Các sorthoạt động có thể không được yêu cầu, nhưng doc cho Enumerable # group_by không đảm bảo Trật tự của các giá trị trong các giá trị băm (là mảng), nhưng các phiên bản hiện tại của Ruby cung cấp một trật tự mong chờ và đặt hàng tôi sẽ cần nếu sortlà xóa khỏi mã của tôi.

Các bước thực hiện như sau.

n=a.size 
  #=> 5 
b=[*(0...n)]
  #=> [0, 1, 2, 3, 4] 
c = b.product(b)
  #=> [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [1, 3],
  #    [1, 4], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 0], [3, 1], [3, 2],
  #    [3, 3], [3, 4], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4]] 
d=c.group_by{|i,j|i+j}
  #=> {0=>[[0, 0]],
  #    1=>[[0, 1], [1, 0]],
  #    2=>[[0, 2], [1, 1], [2, 0]],
  #    3=>[[0, 3], [1, 2], [2, 1], [3, 0]],
  #    4=>[[0, 4], [1, 3], [2, 2], [3, 1], [4, 0]],
  #    5=>[[1, 4], [2, 3], [3, 2], [4, 1]],
  #    6=>[[2, 4], [3, 3], [4, 2]],
  #    7=>[[3, 4], [4, 3]],
  #    8=>[[4, 4]]} 
e=d.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}
  #=> [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5] 
f=e.each_slice(n)
  #=> #<Enumerator: [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2,
  #                  5, 4, 3, 5, 4, 5]:each_slice(5)>

Cuối cùng, f.to_atrả về mảng hiển thị trước đó.