Weź jako dane wejściowe nie zagnieżdżoną tablicę. Zamień go w macierz, używając następującej metody:

Powiedzmy, że moja tablica jest [1, 2, 3, 4, 5]

Najpierw powtarzam tę tablicę 5 razy: (długość)

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

Następnie czytam go wzdłuż przekątnych:

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

Spłaszczam tę tablicę i dzielę na pięć (długość):

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

To jest kod golfowy. Wygrywa najmniej bajtów.

05AB1E, 13 bajtów

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

Wypróbuj online!

Wyjaśnienie:

                # 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

Galaretka , 11 bajtów

WẋLŒDUṙLFsL

Wypróbuj online!

Wyjaśnienie

               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 bajtów

-1 i -4 i -4 bajty dzięki 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)

Pętla for dodaje elementy jak w opisie, prawdziwa magia dzieje się w zipie, który jest stąd

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

Mniej golfa

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
}

Test

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 bajtów

!Gg*tRwZRhPXzGne!

Wypróbuj online!

Jak to działa

Poniższe objaśnienie wykorzystuje dane wejściowe [1 2 3 4 5]jako przykład. Aby wizualizować wyniki pośrednie, wstaw %(symbol komentarza) po dowolnej instrukcji w kodzie.

Zauważ, że ;jest to separator wierszy dla macierzy. Podobnie [1 2]jak wektor rzędowy, wektor [1; 2]kolumnowy i [1 0; 0 1]macierz tożsamości 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 bajtów

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

Cóż, to początek ...

R, 84 bajtów

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

Odczytuje wejście ze standardowego wejścia i wysyła / zwraca macierz 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

Wyjaśniono

Najciekawszym aspektem tej odpowiedzi jest sposób pobierania przekątnych. Zasadniczo obiekt można podzielić za pomocą splitfunkcji, jeśli dostarczono obiekt zawierający czynniki, na które obiekt jest podzielony. Do stworzenia tych czynników możemy użyć coli rowktóre zwracają macierz zawierającą odpowiednio indeksy kolumny i wiersza. Biorąc różnice: row(m)-col(m)otrzymujemy macierz:

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

w którym każda przekątna jest jednoznacznie zidentyfikowana. Możemy teraz podzielić na podstawie tej macierzy i przekształcić ją w poszarpaną listę, stosując 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

(Zwróć uwagę, jak nazwa każdego wektora odpowiada wartościom po przekątnej w powyższej macierzy).

Ostatnim krokiem jest spłaszczenie i przekształcenie go w matrycę formy:

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

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

Oto jak zwykle napisałbym ten kod (109 bajtów):

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

Ten wykres macierzy daje dobry pomysł ze struktury ze względu na sekwencyjnie rosnący wektor wejściowy.

Oto wykres macierzy z losowym wektorem wejściowym. Oczywiście pewna struktura wciąż istnieje.

Mathematica, 92 bajty

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

Nienazwana funkcja przyjmująca listę za argument. Mogą istnieć inne struktury do takiej funkcji, ale mam nadzieję, że grałem w tę strukturę całkiem dobrze ....

Pierwsza część n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&definiuje funkcję ndwóch argumentów: pierwsza to lista długości l, a druga to funkcja do zastosowania do list. nstosuje tę funkcję l-1do odwróconej listy argumentów, zapisując wszystkie wyniki na liście wyników. (Definiowanie ri lpo prostu gra w golfa.)

njest wywoływany dwukrotnie na oryginalnej liście, raz z funkcją będąc Rest(upuść pierwszy element listy) i raz z funkcją będąc Most(upuść ostatni element). Daje to wszystkie pożądane listy podrzędne, ale cała lista jest tam dwa razy (stąd dodatkowa Most), a pierwsza połowa jest tam w odwrotnej kolejności (stąd r[...]). Wreszcie ~ArrayReshape~{l,l}zapomina o bieżącej strukturze listy i wymusza, aby była tablicą lx l.

Mathematica, 85 bajtów

Dosłownie wykonanie sugerowanych kroków:

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

Moja intuicja mówi, że powinien istnieć sprytny sposób, aby Partzrobić to krócej, ale każda próba, którą podjąłem, była dłuższa niż 85 bajtów.

Rubinowy (110 bajtów)

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

sortOperacja nie może być wymagane, ale doc na przeliczalne # group_by nie gwarantuje uporządkowanie wartości w wartości hash (które są macierze), ale obecne wersje Ruby zapewnić jeden zamawiania spodziewałbym i kolejność musiałbym jeśli sortbyły usunięty z mojego kodu.

Kroki są następujące.

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

Na koniec f.to_azwraca tablicę pokazaną wcześniej.