Nehmen Sie ein nicht verschachteltes Array als Eingabe. Verwandeln Sie es mit der folgenden Methode in eine Matrix:

Nehmen wir an, mein Array ist [1, 2, 3, 4, 5]

Zuerst wiederhole ich dieses Array fünfmal: (die Länge)

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

Dann las ich es entlang der Diagonalen:

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

Ich drücke dieses Array flach und teile es in Fünferstücke (die Länge) auf:

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

Das ist Code Golf. Wenigste Bytes gewinnt.

05AB1E, 13 Bytes

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

Probieren Sie es online!

Erläuterung:

                # 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

Gelee , 11 Bytes

WẋLŒDUṙLFsL

Probieren Sie es online!

Erläuterung

               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 Bytes

-1 und -4 und -4 Bytes dank 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)

Die for - Schleife werden die Objekte wie in der Beschreibung, die wirkliche Magie in der Zip geschieht , die aus ist hier

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

Weniger golfen

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
}

Prüfung

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 Bytes

!Gg*tRwZRhPXzGne!

Probieren Sie es online!

Wie es funktioniert

In der folgenden Erläuterung wird die Eingabe [1 2 3 4 5]als Beispiel verwendet. Fügen Sie %nach jeder Anweisung im Code ein (Kommentarsymbol), um die Zwischenergebnisse anzuzeigen .

Beachten Sie, dass dies ;das Zeilentrennzeichen für Matrizen ist. Ist [1 2]also ein Zeilenvektor, [1; 2]ist ein Spaltenvektor und [1 0; 0 1]ist die 2 × 2-Identitätsmatrix.

!     % 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())

Nun, es ist ein Anfang ...

R 84 Bytes

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

Liest die Eingabe von stdin und gibt eine R-Matrix aus / zurück.

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

Erklärt

Das Interessanteste an dieser Antwort ist, wie die Diagonalen ermittelt werden. Im Allgemeinen kann ein Objekt mithilfe der splitFunktion aufgeteilt werden, wenn ein Objekt bereitgestellt wird, das Faktoren enthält, in die das Objekt aufgeteilt wird. Um diese Faktoren zu erzeugen, können wir eine Matrix verwenden colund rowzurückgeben, die den Spalten- bzw. den Zeilenindex enthält. Indem wir die Unterschiede nehmen, erhalten row(m)-col(m)wir eine Matrix wie:

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

in denen jede Diagonale eindeutig identifiziert ist. Wir können nun anhand dieser Matrix aufteilen und sie in eine uneinheitliche Liste umwandeln, indem wir Folgendes anwenden 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

(Beachten Sie, wie der Name jedes Vektors den diagonalen Werten in der obigen Matrix entspricht.)

Der letzte Schritt besteht darin, die Form zu reduzieren und in eine Matrix zu verwandeln:

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

So würde ich diesen Code normalerweise schreiben (109 Bytes):

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

Diese Matrixdarstellung gibt aufgrund eines sequentiell ansteigenden Eingangsvektors eine gute Vorstellung von der Struktur.

Hier ist die Matrixdarstellung mit einem zufälligen Eingabevektor. Offensichtlich existiert noch eine gewisse Struktur.

Mathematica, 92 Bytes

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

Unbenannte Funktion, die eine Liste als Argument verwendet. Es mag andere Strukturen für eine solche Funktion geben, aber ich hoffe, ich habe diese Struktur ziemlich gut gespielt ...

Der erste Teil n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&definiert eine Funktion naus zwei Argumenten: Das erste ist eine Liste der Länge lund das zweite ist eine Funktion, die auf Listen angewendet werden soll. nWendet diese Funktion l-1mal auf die Liste der umgekehrten Argumente an und speichert alle Ergebnisse in ihrer Ausgabeliste. (Definieren rund lauf dem Weg ist nur Golfen.)

nwird in der ursprünglichen Liste zweimal aufgerufen, einmal mit der Funktion Rest(das erste Element der Liste löschen) und einmal mit der Funktion Most(das letzte Element löschen). Dies erzeugt alle gewünschten Unterlisten, aber die gesamte Liste ist zweimal vorhanden (daher das Extra Most) und die erste Hälfte ist in umgekehrter Reihenfolge vorhanden (daher das r[...]). Schließlich ~ArrayReshape~{l,l}vergisst die aktuelle Listenstruktur und zwingt es eine sein lx - lArray.

Mathematica, 85 Bytes

Buchstäblich die vorgeschlagenen Schritte ausführen:

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

Meiner Meinung Partnach sollte es eine clevere Möglichkeit geben, dies zu verkürzen, aber jeder Versuch, den ich unternommen habe, war länger als 85 Byte.

Ruby (110 Bytes)

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

Der sortBetrieb ist möglicherweise nicht erforderlich, aber die doc für Enumerable # group_by nicht die Reihenfolge der Werte in den Hash - Werte garantieren (die Arrays), aber die aktuellen Versionen von Ruby bieten die Bestellung nicht anders erwarten und die Reihenfolge ich brauchen würde , wenn sortwaren aus meinem Code entfernt.

Die Schritte sind wie folgt.

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

Zuletzt wird f.to_adas zuvor gezeigte Array zurückgegeben.