İç içe yerleştirilmemiş bir diziyi girdi olarak alın. Aşağıdaki yöntemi kullanarak bir matrise dönüştürün:

Diyelim ki dizim [1, 2, 3, 4, 5]

İlk olarak, bu diziyi 5 kez tekrarlıyorum: (uzunluk)

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

Sonra, köşegenler boyunca okudum:

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

Bu diziyi düzleştirip beş parçaya (uzunluk) bölüyorum:

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

Bu kod golf. En az bayt kazanır.

05AB1E, 13 bayt

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

Çevrimiçi deneyin!

Açıklama:

                # 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

Jöle , 11 bayt

WẋLŒDUṙLFsL

Çevrimiçi deneyin!

açıklama

               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 bayt

Flp.Tkc sayesinde -1 ve -4 ve -4 bayt

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)

For döngüsü, açıklamadaki gibi öğeleri ekler, gerçek sihir buradan gelen zip'te olur

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

Daha az 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
}

Ölçek

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 bayt

!Gg*tRwZRhPXzGne!

Çevrimiçi deneyin!

Nasıl çalışır

Aşağıdaki açıklamada [1 2 3 4 5]örnek olarak girdi kullanılmıştır. Ara sonuçları görselleştirmek için %, koddaki herhangi bir ifadeden sonra ekleyin (yorum sembolü).

;Matrisler için satır ayırıcı olduğunu unutmayın . Yani [1 2]bir satır vektörü, [1; 2]bir sütun vektörü ve [1 0; 0 1]2 × 2 kimlik matrisi.

!     % 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 bayt

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

Bu bir başlangıç ​​...

R, 84 bayt

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

Stdin'den girişi okur ve bir R-matrisini verir / döndürü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

Açıklaması

Bu cevapla ilgili en ilginç husus, köşegenlerin nasıl geri alındığıdır. Genel olarak, bir nesne, splitüzerine nesnenin bölündüğü faktörleri içeren bir nesne sağlandığında işlev kullanılarak bölünebilir. Kullanabileceđimiz bu faktörleri oluşturmak için colve rowsırasıyla kolon ve sıra indislerini içeren bir matris döndürür. Farkları alarak: row(m)-col(m)şöyle bir matris elde ederiz:

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

burada her köşegen benzersiz olarak tanımlanır. Şimdi bu matrise dayanarak bölünebilir ve uygulayarak düzensiz bir listeye dönüştürebiliriz 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

(Her vektörün adının yukarıdaki matristeki köşegen değerlere nasıl karşılık geldiğine dikkat edin).

Son adım sadece düzleştirmek ve formun bir matrisine dönüştürmektir:

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

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

Normalde bu kodu (109 bayt) nasıl yazacağım:

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

Bu matris grafiği, ardışık olarak artan bir girdi vektörü nedeniyle yapıdan iyi bir fikir verir.

Rastgele bir giriş vektörü içeren matris grafiği. Açıkçası bazı yapılar hala var.

Mathematica, 92 bayt

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

Adsız işlev, listeyi argüman olarak alır. Böyle bir işlev için başka yapılar olabilir, ama umarım bu yapıyı oldukça iyi golf oynadım ....

İlk bölüm iki argümanın n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&bir fonksiyonunu tanımlar n: birincisi bir uzunluk listesidir lve ikincisi listelere uygulanacak bir fonksiyondur. nbu işlev l-1sürelerini, tüm sonuçları çıkış listesine kaydederek ters argüman listesine uygular . (Tanımlamak rve lyol boyunca sadece golf oynamaktır.)

norijinal listede iki kez çağrılır, bir kez işlev Rest(listenin ilk öğesini bırak) ve bir kez işlev Most(son öğeyi bırak ) ile çağrılır . Bu istenen tüm alt listeleri üretir, ancak tüm liste iki kez vardır (bu nedenle ekstra Most) ve ilk yarı geriye doğru sıradadır (dolayısıyla r[...]). Son olarak, ~ArrayReshape~{l,l}geçerli liste yapısını unutur ve onu lx ldizisi olmaya zorlar .

Mathematica, 85 bayt

Kelimenin tam anlamıyla aşağıdaki adımları uygulayın:

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

Bağırsak, Partbunu daha kısa yapmak için akıllıca bir yol olması gerektiğini söylüyor , ancak yaptığım her girişim 85 bayttan daha uzun.

Yakut (110 bayt)

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

sortOperasyon gerekmeyebilir, ancak Enumerable # group_by için doc hash değerleri değerlerin sipariş (diziler olan) garanti etmez, ancak Ruby güncel versiyonları sipariş bir beklenebilir sağlamak ve eğer sipariş ı gerekir sortidi kodumdan kaldırıldı.

Adımlar aşağıdaki gibidir.

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

Son olarak, f.to_adaha önce gösterilen diziyi döndürür.