Ambil array yang tidak bersarang sebagai input. Ubah menjadi matriks dengan menggunakan metode berikut:

Katakanlah array saya adalah [1, 2, 3, 4, 5]

Pertama, saya ulangi array itu 5 kali: (panjangnya)

[[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]]

Kemudian, saya membacanya di sepanjang diagonal:

[[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]]

Saya meratakan array ini dan membaginya menjadi lima bagian (panjangnya):

[[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]]

Ini golf kode. Bytes paling sedikit menang.

05AB1E, 13 byte

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

Cobalah online!

Penjelasan:

                # 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

Jelly , 11 byte

WẋLŒDUṙLFsL

Cobalah online!

Penjelasan

               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 dan -4 dan -4 byte berkat 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)

Untuk loop menambahkan item seperti dalam deskripsi, keajaiban nyata terjadi di zip yang berasal dari sini

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")

Kurang golf

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
}

Uji

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!

Cobalah online!

Bagaimana itu bekerja

Penjelasan berikut menggunakan input [1 2 3 4 5]sebagai contoh. Untuk memvisualisasikan hasil antara, masukkan% (simbol komentar) setelah pernyataan dalam kode.

Perhatikan bahwa ;pemisah baris untuk matriks. Begitu [1 2]juga vektor baris, [1; 2]adalah vektor kolom, dan [1 0; 0 1]merupakan matriks identitas 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())

Yah, ini awal ...

R, 84 byte

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

Membaca input dari stdin dan menghasilkan / mengembalikan R-matrix.

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

Dijelaskan

Aspek yang paling menarik tentang jawaban ini adalah bagaimana diagonal diambil. Secara umum suatu objek dapat dibagi menggunakan splitfungsi jika disediakan suatu objek yang mengandung faktor-faktor di mana objek tersebut dibagi menjadi. Untuk membuat faktor-faktor ini kita dapat menggunakan coldan rowyang mengembalikan matriks yang berisi indeks kolom dan baris masing-masing. Dengan mengambil perbedaan: row(m)-col(m)kita mendapatkan matriks seperti:

     [,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

di mana setiap diagonal diidentifikasi secara unik. Kami sekarang dapat membagi berdasarkan matriks ini dan mengubahnya menjadi daftar kasar dengan menerapkan 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

(Perhatikan bagaimana nama masing-masing vektor sesuai dengan nilai-nilai diagonal dalam matriks di atas).

Langkah terakhir adalah meratakan dan mengubahnya menjadi matriks bentuk:

     [,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

Mathematica 93 Bytes

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

Inilah cara saya biasanya menulis kode ini (109 Bytes):

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

Plot matriks ini memberikan ide yang baik dari struktur karena vektor input meningkat secara berurutan.

Inilah plot matriks dengan vektor input acak. Jelas beberapa struktur masih ada.

Mathematica, 92 byte

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

Fungsi yang tidak disebutkan namanya mengambil daftar sebagai argumennya. Mungkin ada struktur lain untuk fungsi seperti itu, tapi mudah-mudahan saya bermain golf struktur ini cukup bagus ....

Bagian pertama n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&mendefinisikan fungsi ndari dua argumen: yang pertama adalah daftar panjang l, dan yang kedua adalah fungsi untuk diterapkan ke daftar. nmenerapkan fungsi tersebut l-1kali ke daftar argumen terbalik, menyimpan semua hasil dalam daftar outputnya. (Mendefinisikan rdan lsepanjang jalan hanya bermain golf.)

ndipanggil dua kali pada daftar asli, sekali dengan fungsi sedang Rest(drop elemen pertama dari daftar) dan sekali dengan fungsi sedang Most(drop elemen terakhir). Ini menghasilkan semua daftar yang diinginkan, tetapi seluruh daftar ada dua kali (maka tambahan Most) dan setengah pertama ada di urutan terbalik (karenanya r[...]). Akhirnya, ~ArrayReshape~{l,l}lupa struktur daftar saat ini dan memaksanya menjadi lx larray.

Mathematica, 85 byte

Secara harfiah melakukan langkah-langkah yang disarankan:

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

Naluri saya mengatakan bahwa harus ada cara pintar Partuntuk melakukan ini lebih pendek, tetapi setiap upaya yang saya lakukan telah lebih dari 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]]

The sortoperasi mungkin tidak diperlukan, tetapi doc untuk Enumerable # group_by tidak menjamin urutan nilai dalam nilai-nilai hash (yang adalah array), tetapi versi saat ini dari Ruby memberikan satu pemesanan harapkan dan memesan saya akan butuhkan jika sortberada dihapus dari kode saya.

Langkah-langkahnya adalah sebagai berikut.

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)>

Terakhir, f.to_amengembalikan array yang ditunjukkan sebelumnya.