Addieren Sie bei einer gegebenen Matrix ihre Werte nach oben / unten oder links / rechts, um ein X zu bilden, falten Sie es nach oben und geben Sie die Liste zurück. Ich beschreibe den Algorithmus hier:

Algorithmus

Bei Ihrer Eingabe handelt es sich um eine quadratische Matrix mit ungeraden Zahlenwerten, die der angemessenen numerischen Kapazität Ihrer Sprache entspricht.

Nehmen wir als Beispiel die folgende Matrix:

1 2 3 2 1
0 3 2 3 0
4 2 5 6 3
7 4 7 9 4
0 6 7 2 5

Addieren Sie zunächst jede Zahl zu der nächstgelegenen Zahl auf der Hauptdiagonale oder der Antidiagonale. Das heißt, teilen Sie die Matrix in vier Abschnitte entlang der Hauptdiagonale und der Antidiagonale und addieren Sie dann alle Zahlen in jedem Abschnitt in Richtung der Mitte wie folgt:

1   2   3   2   1
    ↓   ↓   ↓    
0 → 3   2   3 ← 0
        ↓        
4 → 2 → 5 ← 6 ← 3
        ↑        
7 → 4   7   9 ← 4
    ↑   ↑   ↑    
0   6   7   2   5

Dieser Schritt ergibt folgendes Ergebnis:

1        1
  5    5
    39
  17  15
0        5

Dann falten wir es, indem wir das X abflachen und die Elemente mit der linken oberen zuerst und der linken unteren zuletzt verweben. Dies ergibt folgendes Ergebnis:

1, 0, 5, 17, 39, 5, 15, 1, 5

Sie können sich vorstellen, die Hauptdiagonale zu dehnen und sie gegen den Uhrzeigersinn zu drehen.

Dies ist das Endergebnis.

Herausforderung

Implementieren Sie diesen Algorithmus. Es gelten Standardlücken. Alle sinnvollen E / A-Formate sind akzeptabel.

Testfälle

Input
Output

1 2 3 2 1
0 3 2 3 0
4 2 5 6 3
7 4 7 9 4
0 6 7 2 5

1, 0, 5, 17, 39, 5, 15, 1, 5

1 2 3 4 5
5 4 3 2 1
1 3 5 7 9
0 9 8 7 6
6 7 8 9 0

1, 6, 11, 16, 47, 7, 22, 5, 0

1 3 7 4 8 5 3
8 4 7 5 3 8 0
0 6 3 6 9 8 4
2 6 5 8 7 4 2
0 6 4 3 2 7 5
0 6 7 8 5 7 4
8 5 3 2 6 7 9

1, 8, 15, 11, 23, 20, 62, 32, 25, 13, 18, 3, 9

JavaScript, 113 Bytes

s=>(l=s.length-1,a=[],s.map((v,y)=>v.map((n,x)=>a[q=2*[x,y,l-y].sort((u,v)=>u-v)[1]+(y>l/2),q-=q>l]=~~a[q]+n)),a)

f=

s=>(l=s.length-1,a=[],s.map((v,y)=>v.map((n,x)=>a[q=2*[x,y,l-y].sort((u,v)=>u-v)[1]+(y>l/2),q-=q>l]=~~a[q]+n)),a)

<p><textarea id="i" style="width: 400px; height: 120px">1 2 3 2 1
0 3 2 3 0
4 2 5 6 3
7 4 7 9 4
0 6 7 2 5</textarea></p>
<p><button onclick="o.value=f(i.value.trim().split`\n`.map(l=>l.trim().split(/\s+/).map(v => parseInt(v,10)))).join` `">Run</button></p>
<p><output id="o"></output></p>

Jelly , 25 23 21 Bytes

AṂ×ṠṚ
LHŒRṗ2Ç€ḅLĠịFS€

Probieren Sie es online!

Alternative Version, 19 Byte

AṂ×ṠṚ
LHŒRṗ2Ç€ĠịFS€

Dies hat nicht funktioniert, da Ġsich verschachtelte Arrays nicht ordnungsgemäß verhalten haben. Der einzige Unterschied ist , dass die Paare [q, p] in erwähnt , wie es funktioniert sortiert sind lexikographisch anstelle des Abbildens sie zu p + nq vor dem Sortieren.

Probieren Sie es online!

Hintergrund

Wir beginnen damit, die Elemente durch Koordinaten zu ersetzen, nach links und unten zu erhöhen und (0, 0) zu platzieren. in der Mitte der Matrix zu platzieren.

Für eine 7x7 Matrix M erhalten wir die folgenden Koordinaten.

(-3,-3) (-3,-2) (-3,-1) (-3, 0) (-3, 1) (-3, 2) (-3, 3)
(-2,-3) (-2,-2) (-2,-1) (-2, 0) (-2, 1) (-2, 2) (-2, 3)
(-1,-3) (-1,-2) (-1,-1) (-1, 0) (-1, 1) (-1, 2) (-1, 3)
( 0,-3) ( 0,-2) ( 0,-1) ( 0, 0) ( 0, 1) ( 0, 2) ( 0, 3)
( 1,-3) ( 1,-2) ( 1,-1) ( 1, 0) ( 1, 1) ( 1, 2) ( 1, 3)
( 2,-3) ( 2,-2) ( 2,-1) ( 2, 0) ( 2, 1) ( 2, 2) ( 2, 3)
( 3,-3) ( 3,-2) ( 3,-1) ( 3, 0) ( 3, 1) ( 3, 2) ( 3, 3)

Wir berechnen nun den minimalen Absolutwert jedes Koordinatenpaares und multiplizieren die Vorzeichen beider Koordinaten damit, indem wir (i, j) auf (Vorzeichen (i) m, Vorzeichen (j) m) abbilden. , wobei m = min (| i | , | j |) .

(-3,-3) (-2,-2) (-1,-1) ( 0, 0) (-1, 1) (-2, 2) (-3, 3)
(-2,-2) (-2,-2) (-1,-1) ( 0, 0) (-1, 1) (-2, 2) (-2, 2)
(-1,-1) (-1,-1) (-1,-1) ( 0, 0) (-1, 1) (-1, 1) (-1, 1)
( 0, 0) ( 0, 0) ( 0, 0) ( 0, 0) ( 0, 0) ( 0, 0) ( 0, 0)
( 1,-1) ( 1,-1) ( 1,-1) ( 0, 0) ( 1, 1) ( 1, 1) ( 1, 1)
( 2,-2) ( 2,-2) ( 1,-1) ( 0, 0) ( 1, 1) ( 2, 2) ( 2, 2)
( 3,-3) ( 2,-2) ( 1,-1) ( 0, 0) ( 1, 1) ( 2, 2) ( 3, 3)

Matrixelemente, die demselben Paar entsprechen, müssen summiert werden. Um die Reihenfolge der Summen zu bestimmen, bilden wir jedes Paar (p, q) auf p + nq ab , wobei n die Anzahl der Zeilen / Spalten von M ist .

-24 -16  -8   0   6  12  18
-16 -16  -8   0   6  12  12
 -8  -8  -8   0   6   6   6
  0   0   0   0   0   0   0
 -6  -6  -6   0   8   8   8
-12 -12  -6   0   8  16  16
-18 -12  -6   0   8  16  24

Die Reihenfolge der Summen entspricht der Reihenfolge der ganzen Zahlen und ihrer Summanden.

Wie es funktioniert

LHŒRṗ2Ç€ḅLĠịFS€  Main link. Argument: M (matrix)

L                Compute n, the length (number of rows) of M.
 H               Halve it.
  ŒR             Symmetric range; map t to [-int(t), ..., 0, int(t)].
    ṗ2           Compute the second Cartesian power, yielding all pairs [i, j]
                 with -t ≤ i, j ≤ t.
      ǀ         Map the helper link over the resulting array of pairs.
         L       Yield n.
        ḅ        Unbase; map each pair [q, p] to (p + nq).
          Ġ      Group the indices of the resulting array of n² integers by their
                 corresponding values, ordering the groups by the values.
            F    Flatten M.
           ị     Index into the serialized matrix.
             S€  Compute the sum of each group.


AṂ×ṠṚ            Helper link. Argument: [i, j] (index pair)

A                Absolute value; yield [|i|, |j|].
 Ṃ               Minimum; yield m := min(|i|, |j|).
   Ṡ             Sign; yield [sign(i), sign(j)].
  ×              Multiply; yield [p, q] := [sign(i)m, sign(j)m].
    Ṛ            Reverse; yield [q, p].

Python, 159 158 Bytes

def f(m):l=len(m)-1;r=range(1,l);return m[0][::l]+f([[sum(m[x][1%y*y:(y>l-2)-~y])+m[0][y]*(x<2)+m[l][y]*(x>l-2)for y in r]for x in r])+m[l][::l]if l else m[0]

Probieren Sie es online!

Dyalog APL , 101 99 64 62 59 Bytes

_{3 Bytes von @ Adám gespeichert}

{+/∘,¨⍵∘רd∘=¨k[⍋k←↑∪/,d←∘.((+/1x×××⌊/∘|),)⍨(⍳x)-⌈.5×x←≢⍵]}

Probieren Sie es online!

Mit Dennis ' fantastischem Algorithmus .

APL (Dyalog) , 60 Byte *

In Zusammenarbeit mit meinem Kollegen Marshall .

Anonymes Präfix Lambda. Nimmt Matrix als Argument und gibt Vektor zurück. Geht davon aus ⎕IO ( I ndex O Rigin) Null sein, die standardmäßig auf vielen Systemen ist.

{(,⍉{+/,(s×-×⍺)↓⍵×i∊¨⍨s←⌊⊃r÷2}⌺r⊢⍵)/⍨,(⊢∨⌽)=/¨i←⍳r←⍴⍵}

Probieren Sie es online!

{… } Anonymes Lambda;⍵ist das richtige Argument (als äußerster rechter Buchstabe des griechischen Alphabets):

 ⍴⍵ Form des Arguments (Liste zweier identischer Elemente)

 r← speichern als r(wie in r ho)

 ⍳ Alle ɩ ndices einer Anordnung von dieser Größe, das heißt (0 0),(0 1) ...

 i← speichern in i(wie in i ota)

 =/¨ Boolescher Wert, bei dem die Koordinaten gleich sind (dh die Diagonale)

 (…)  Wende diese anonyme implizite Präfixfunktion an:

  ⌽ kehren Sie das Argument um

  ⊢∨ ODER das mit dem unveränderten Argument

 , ravel (in einfache Liste glätten)

 Wir haben jetzt eine Boolesche Maske für die Diagonalen.

 (… Damit )/⍨ filtern Sie Folgendes:

  ⊢⍵ Geben Sie rdas Argument (um es zu trennen )

  {... }⌺r auf jedes Elemente das folgende anonymous Infix lambda nennen, mit dem r-Umgebung (mit Nullen aufgefüllt , wie erforderlich) als rechtes Argument ( ⍵), und eine Zwei - Element - Liste der Anzahl gepolsterter Zeilen, Spalten (negativ für Boden / rechts, Null für keine) als linkes Argument ( ⍺):

   r÷2rmit zwei  teilen

   ⊃ wähle das erste Element (sie sind identisch)

   ⌊ Boden es

   s← Speicher als s(für s hape)

   i∊⍨¨ für jedes Element von iist Boolean if sein Mitglied davon

   ⍵× multiplizieren Sie die Nachbarschaft damit

   (… )↓ Löschen Sie die folgende Anzahl von Zeilen und Spalten (negativ für unten / rechts):

    ×⍺ Zeichen des linken Arguments (dh die Richtung der Auffüllungen)

    - negieren

    s× multiplizieren Sie sdamit

   , ravel (in Liste begradigen)

   +/ Summe (plus Ermäßigung)

Jetzt haben wir eine vollständige Summenmatrix, aber wir müssen alle gelesenen Werte spaltenweise filtern.

  ⍉ transponieren

  , ravel (in einfache Liste glätten)

* Durch Zählen ⌺als ⎕U233A .Probieren Sie es online!