Korrigieren Sie meine Notation für Matrizenlisten, Teil 1

21

Manchmal habe ich Listen mit konstanten Matrizen in meinem Code:

[ [[1, 0],
   [0, 1]],

  [[1, 0],
   [0,-1]],

  [[0, 1],
   [1, 0]],

  [[0,-1],
   [1, 0]] ]

Das ist eine schreckliche Nutzung von Bildschirmgrundstücken. Ich würde sie viel lieber nebeneinander schreiben:

[   [[1, 0],    [[1, 0],    [[0, 1],    [[0,-1],
     [0, 1]],    [0,-1]],    [1, 0]],    [1, 0]]   ]

Sie werden feststellen, dass dies immer noch eine syntaktisch gültige verschachtelte Liste ist, sie nicht mehr rechteckig ist und eine ganz andere Struktur aufweist (insbesondere wird sie mit jedem Hinzufügen einer Matrix größer als 1x1 tiefer). Es ist jedoch weiterhin möglich, die ursprüngliche Liste der Matrizen aus dieser neuen Liste zu rekonstruieren.

Damit ich diese Syntax in Zukunft verwenden kann, müssen Sie Code schreiben, der in horizontaler Anordnung geschriebene Arrays in die Liste der Matrizen konvertiert, die sie darstellen.

Um sicherzustellen, dass Antworten keinen 2D-Musterabgleich für das Layout im Quellcode durchführen, wird die Eingabe entweder nur als Array-Objekt angegeben, oder wenn Sie eine Zeichenfolgendarstellung verwenden, enthält sie kein Leerzeichen, das angibt, wie das Literal wurde in den Code geschrieben. Sie würden also eine Eingabe wie diese erhalten:

[[[1, 0], [[1, 0], [[0, 1], [[0,-1], [0, 1]], [0,-1]], [1, 0]], [1, 0]]]

Die Ausgabe sollte das folgende Array oder seine Zeichenfolgendarstellung sein (wiederum ist kein weiteres Layout erforderlich):

[[[1, 0], [0, 1]], [[1, 0], [0,-1]], [[0, 1], [1, 0]], [[0,-1], [1, 0]]]

Dies ist der erste und einfachere Teil einer zweiteiligen Herausforderung. In diesem Fall können Sie davon ausgehen, dass alle Matrizen quadratisch sind, die gleichen Abmessungen haben und ordnungsgemäß nebeneinander ausgerichtet sind. Im zweiten Teil werden wir diese Annahmen lockern.

Regeln

Die Eingabe ist eine verschachtelte Liste oder deren kanonische Zeichenfolgendarstellung (in der Sprache Ihrer Wahl), und Sie sollten das Ergebnis im gleichen Format ausgeben. Das Ergebnis enthält immer mindestens eine Matrix, und die Matrizen können so klein wie 1x1 sein. Die Matrizen enthalten nur (vorzeichenbehaftete) Ganzzahlen mit einem absoluten Wert von weniger als 128.

Sie können ein Programm oder eine Funktion schreiben und eine der Standardmethoden zum Empfangen von Eingaben und zum Bereitstellen von Ausgaben verwenden.

Sie können jede Programmiersprache verwenden , aber beachten Sie, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

Jeder Testfall enthält a) die Listenmatrizen, die wie im Code angeordnet sind (dies ist nicht Ihre Eingabe), b) die unformatierte Liste ohne das überflüssige Leerzeichen ( dies ist Ihre Eingabe), c) die erwartete Ausgabe.

Pretty: [ [[0]] ]
Input:  [[[0]]]
Output: [[[0]]]

Pretty: [  [[-1]],  [[0]],  [[1]]  ]
Input:  [[[-1]],[[0]],[[1]]]
Output: [[[-1]],[[0]],[[1]]]

Pretty: [  [[1, 0],   [[1, 0],   [[0, 1],   [[0,-1],
            [0, 1]],   [0,-1]],   [1, 0]],   [1, 0]]  ]
Input:  [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]]
Output: [[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]

Pretty: [  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
            [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
            [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]
Input:  [[[1,0,0],[[127,63,31],[[1,0,0],[[0,0,0],[0,1,0],[15,0,-15],[0,0,1],[0,0,0],[0,0,1]],[-31,-63,-127]],[0,1,0]],[0,0,0]]]
Output: [[[1,0,0],[0,1,0],[0,0,1]],[[127,63,31],[15,0,-15],[-31,-63,-127]],[[1,0,0],[0,0,1],[0,1,0]],[[0,0,0],[0,0,0],[0,0,0]]]
code-golf  array-manipulation  matrix  syntax 
— Martin Ender
quelle
1
Ich denke, ich könnte wissen, was diese Herausforderung inspiriert hat ...
— Neil
Ist [([1, 0], [0, 1]), ([1, 0], [0, -1]), ([0, 1], [1, 0]), ([0, -1], [1, 0])]die Ausgabe für den dritten Testfall gültig? Es ist gemischte Liste und Tupel.
— Ovs
@ovs Nein, sorry. Da Eingabe- und Ausgabeformat übereinstimmen sollten, wäre die entsprechende Eingabe [([1,0], ([1, 0}, ...und das würde Ihnen zusätzliche Informationen geben.
— Martin Ender
@Neil was hat diese Herausforderung inspiriert?
— Caird Coinheringaahing
@ RandomUser Der Wunsch, alle Dinge zu golfen. Die geringste Anzahl von Bildschirmimmobilien gewinnt!
— Dennis

Antworten:

14

Jelly , 20 15 13 11 Bytes

Fðs⁹œsZµḢḢL

Probieren Sie es online!

Hintergrund

Wie die meisten Dinge ist diese Herausforderung ziemlich einfach, sobald Sie herausgefunden haben, was Sie tun müssen. Und ich tat es schließlich nach drei Streichungen und einem Rollback ...

Zuerst müssen wir die Dimensionen der Matrizen herausfinden. Das ist einfacher als gesagt: Das erste Element des ersten Elements ist die erste Zeile der ersten Ausgabematrix, ihre Länge entspricht also der Anzahl der Spalten der quadratischen Ausgabematrizen.

Zum Beispiel, wenn die Eingabe ist

[  [[1, 0, 0],   [[ 127,  63,   31],   [[1, 0, 0],   [[0, 0, 0],
    [0, 1, 0],    [  15,   0,  -15],    [0, 0, 1],    [0, 0, 0],
    [0, 0, 1]],   [ -31, -63, -127]],   [0, 1, 0]],   [0, 0, 0]]  ]

das erste Element des ersten Elements ist [1, 0, 0], dessen Länge ℓ = 3 ist .

Wenn wir die Eingabe abflachen und in Abschnitte dieser Länge aufteilen, erhalten wir alle Zeilen der Ausgabematrizen, allerdings in der falschen Reihenfolge. Für unsere Beispieleingabe ergibt dies

[  [1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0],
   [0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0],
   [0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]  ]

Um die endgültige Ausgabe zu erhalten, müssen wir zuerst das Zeilenarray in ℓ gleich lange Abschnitte aufteilen . Für unsere Beispieleingabe ergibt dies

[ [[1, 0, 0], [127,  63,   31], [1, 0, 0], [0, 0, 0]],
  [[0, 1, 0], [ 15,  0,   -15], [0, 0, 1], [0, 0, 0]],
  [[0, 0, 1], [-31, -63, -127], [0, 1, 0], [0, 0, 0]] ]

Jede Spalte ist jetzt eine der Ausgabematrizen. Sie müssen also nur noch die resultierende Matrix von Arrays transponieren. Für unsere Beispieleingabe gibt das

[
 [[1, 0, 0],
  [0, 1, 0],
  [0, 0, 1]],

 [[127,  63,   31],
  [ 15,   0,  -15],
  [-31, -63, -127]],

 [[1, 0, 0],
  [0, 0, 1],
  [0, 1, 0]],

 [[0, 0, 0],
  [0, 0, 0],
  [0, 0, 0]]
]

wie gewünscht.

Wie es funktioniert

Fðs⁹œsZµḢḢL  Monadic link. Argument: A (ragged array)


F            Monadic chain. Argument: A

F            Flatten A. This yields the vector V.


       µḢḢL  Monadic chain. Argument: A

        Ḣ    Head; retrieve the first element of A.
         Ḣ   Head; retrieve the first element of the first element of A.
          L  Compute ℓ, the length of the resulting array.


 ðs⁹œsZ      Dyadic chain. Left argument: V. Right argument: ℓ

  s⁹         Split V into chunks of length ℓ.
    œs       Split the result into ℓ chunks of equal length.
      Z      Zip/transpose the result.
— Dennis
quelle
6

Pyth , 12 Bytes

CcJlhhQc.nQJ

Dies ist eine Portierung meiner Gelee-Antwort.

Probieren Sie es online!

Wie es funktioniert

Pyth analysiert das Programm wie folgt (Pseudocode).

C(c(J = l(h(h(Q))), c(.n(Q), J)))

Q ist eine Variable, die die Eingabe enthält. J ist eine undefinierte Variable.

Zuerst J = l(h(h(Q)))speichert die Länge des Kopfes (ersten Elements) des Kopfes von Q in J .

Dann wird Q.n(Q) geglättet und das Ergebnis in Stücke der Länge J aufgeteilt .c(..., J)

Anschließend wird c(J, ...)das Ergebnis in J- Teile geteilt.

Zum Schluss C(...)transponiert das Ergebnis.

— Dennis
quelle
1
sancta mater dei
— Undichte Nonne
3

Pyth , 29 Bytes

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

Testsuite.

Wie es funktioniert

.xj\,sCcJh-UJ:z"\B,"3x\[@R1Jz

              z        input
             :      3  split at matches of the following regex
               "\B,"   /\B,/
            J          store at J
           U           [1,2,...,len(J)]

                           J  J
                        @R1   take the second character of each
                              substring in J
                     x\[      indices of all occurrences of "["

          -   filter away the elements in ^ from the
              elements in ^^ to find the first substring
              which does not start with "[["
         h    the first element
              note: this will generate an error if
              all substrings start with "[[", e.g. in the
              first example. We will deal with the error later.
       cJ     split J in groups of the specified length
      C       transpose                             ^
     s        flatten                               |
  j\,         join with ","                         |
.x            if the above code generated an error (|), return
              the following instead:
                            z      the input

Algorithmus

Lassen Sie uns an der Eingabe arbeiten [[[1,0],[[1,0],[[0,1],[[0,-1],[0,1]],[0,-1]],[1,0]],[1,0]]] .

Wir werden hier reine Zeichenkettenoperationen verwenden.

Erstens teilen wir die Eingabe an den Kommas auf, die nicht Teil der tiefsten Liste sind (dies geschieht durch Aufteilen an der regulären Schreibweise \B,):

[[[1,0]
[[1,0]
[[0,1]
[[0,-1]
[0,1]]
[0,-1]]
[1,0]]
[1,0]]]

Dann finden wir den Index des ersten Teilstrings, der nicht mit "index" beginnt [[(dies geschieht, indem geprüft wird, ob das Zeichen am Index "index" 1ist [). In diesem Fall, 4weil der Teilstring bei Index 4 [0,1]]nicht mit beginnt [[.

Dann gruppieren wir die Teilzeichenfolgen in Gruppen von 4 und transponieren dann:

[[[1,0]
[0,1]]
[[1,0]
[0,-1]]
[[0,1]
[1,0]]
[[0,-1]
[1,0]]]

Und dann schließen wir sie mit Kommas an:

[[[1,0],[0,1]],[[1,0],[0,-1]],[[0,1],[1,0]],[[0,-1],[1,0]]]
— Undichte Nonne
quelle
2
Du wurdest nur massiv von Dennis überrumpelt .
— Erik der Outgolfer
3

JavaScript (ES6), 132 - 130 Byte

f=(a,n=1)=>a[0][n]?a[0][n][0][0]?f(a,n+1,a[0].splice(n,1,...a[0][n])):n>1?[...Array(n)].map((_,i)=>a[0].filter((_,j)=>j%n==i)):a:a

Es gibt vier Fälle:

  • Ein 1 × n-Array, das gerade zurückgegeben wird (dies ist der erste Test, aber invertiert)
  • Ein noch nicht abgeflachtes m × n-Array, das wir rekursiv um einen Schritt abflachen und ngleichzeitig zählen.
  • Ein abgeflachtes m × n-Array, in dem wir alle herausfiltern n Element herausgefiltert wird.
  • Ein m × 1-Array, das gerade zurückgegeben wird
— Neil
quelle
1

Mathematica, 104 Bytes

l=Length;(m=l@#[[1,1]];n=l@Flatten@#/m;Table[Partition[#~ArrayReshape~{n,m},n/m][[j,i]],{i,n/m},{j,m}])&

Eingang

{{{1, 0}, {{1, 0}, {{0, 1}, {{0, -1}, {0, 1}}, {0, -1}}, {1, 0} }, {1, 0}}}

Ausgabe

{{{1, 0}, {0, 1}}, {{1, 0}, {0, -1}}, {{0, 1}, {1, 0}}, {{0, -1 }, {1, 0}}}

Eingang

{{{1, 0, 0}, {{127, 63, 31}, {{1, 0, 0}, {{0, 0, 0}, {0, 1, 0}, {15, 0, -15}, {0, 0, 1}, {0, 0, 0}, {0, 0, 1}}, {-31, -63, -127}}, {0, 1, 0}}, {0, 0, 0}}}

Ausgabe

{{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}, {{127, 63, 31}, {15, 0, -15}, {-31, - 63, -127}}, {{1, 0, 0}, {0, 0, 1}, {0, 1, 0}}, {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}}}

{{{0}}} und {{{-1}}, {{0}}, {{1}}} funktionieren auch

-11 Bytes dank Martin Ender

— J42161217
quelle
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.