Verwandle dieses Array in eine Matrix


13

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.


Bitte kapitalisieren Sie das nächste Mal die Dinge.
Oliver Ni

Wie funktioniert das, wenn das ursprüngliche Array eine andere Länge als 5 hat?

@ ais523 Ich gehe davon aus, dass es dasselbe ist, Sie ersetzen einfach 'fünf' durch die Länge
Oliver Ni

Können wir annehmen, dass die Zahlen immer positive ganze Zahlen sind?
Luis Mendo

7
@JohnCena Du solltest die erste Antwort nicht akzeptieren, du musst dem Post etwas Zeit geben, um Traktion zu erlangen und einige weitere Antworten.
Kade

Antworten:


2

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

brauchst du es nicht zu drucken

und wie haben Sie die Eingabe

1
Viele dieser Golfsprachen, wie 05AB1E, haben Standardregeln zum Anfordern von Eingaben und zum Erzeugen von Ausgaben eingebaut, damit der Programmierer keine Bytes damit verschwenden muss.

1
Die Ausgabe entspricht nicht wirklich der gewünschten Ausgabe. Es ist keine Matrix und die Zahlen stimmen nicht überein.
Karl Napf

1
Nun, es ist eine Matrix, aber die Zahlen sind nicht korrekt (oder tryitonline.net berechnet falsch)
Karl Napf

6

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)

Hmm, als ich es damit ausprobiert Lhabe, habe ich seltsame Sachen gemacht, daher habe ich das Register benutzt: / Ich habe es einfach noch einmal ausprobiert und es funktioniert ... im Grunde das Gleiche, also werde ich wohl einfach meins entfernen.
Jonathan Allan

1
Natürlich hat Jelly "Diagonalen" eingebaut .... :)
Greg Martin

3

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


Entschuldigung für den Spam, aber jetzt, da R nur einmal verwendet wird, können Sie es einfach direkt dort
ablegen

@ Flp.Tkc kein Problem, ich bin glücklich :)
Karl Napf

3

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>


1
Wow, das ist eine sehr clevere Art, dem auszuweichen return. Du solltest einen Tipp dazu im ES6-Thread posten.
ETHproductions

@ETHproductions es hat einen sehr engen Umfang. Meistens ist eval besser.
EDC65

@ETHproductions ist in der Tat evalsogar dieses Mal besser :(
edc65

@ETHproductions Ich habe den Tipp gepostet, auch wenn er selten nützlich ist, nur für den Fall
edc65

2

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]

1

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


1

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

0

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.

Bildbeschreibung hier eingeben

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

Bildbeschreibung hier eingeben


0

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.


0

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.


0

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.

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.