Nehmen Sie eine nicht leere Matrix / ein nicht leeres numerisches Array mit positiven ganzen Zahlen als Eingabe. Geben Sie in dieser Reihenfolge die Summen der ersten Zeile und Spalte, dann der zweiten Zeile und Spalte zurück und fahren Sie fort, bis keine Zeilen oder Spalten mehr vorhanden sind.

Angenommen, die Eingabe lautet:

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

Dann sollte die Ausgabe sein:

45, 33, 16, 17

Denn: 2+9+1+7+10+10+2+4=45, 7+7+1+7+2+9=33, 6+4+2+4=16, 8+9=17.

Testfälle:

Testfälle haben das folgende Format:

Input
---
Output

5
---
5
..........

1  4
----
5
..........

7
2
---
9
..........

 8    3    7   10    3    7   10    1
10    7    5    8    4    3    3    1
 1    6    4    1    3    6   10    1
 2    3    8    2    8    3    4    1
---
62   40   33   18
..........

30    39    48     1    10    19    28
38    47     7     9    18    27    29
46     6     8    17    26    35    37
 5    14    16    25    34    36    45
13    15    24    33    42    44     4
21    23    32    41    43     3    12
22    31    40    49     2    11    20
---
320  226   235   263   135    26    20
..........

7   10    1
4    4    2
6    3    4
1    4   10
5    7    6
---
34   20   20

Als Arrays:

[[5]]
[[1,4]]
[[7],[2]]
[[8,3,7,10,3,7,10,1],[10,7,5,8,4,3,3,1],[1,6,4,1,3,6,10,1],[2,3,8,2,8,3,4,1]]
[[30,39,48,1,10,19,28],[38,47,7,9,18,27,29],[46,6,8,17,26,35,37],[5,14,16,25,34,36,45],[13,15,24,33,42,44,4],[21,23,32,41,43,3,12],[22,31,40,49,2,11,20]]
[[7,10,1],[4,4,2],[6,3,4],[1,4,10],[5,7,6]]

Das ist Code-Golf, also gewinnt die kürzeste Lösung in jeder Sprache.

MATL , 16 Bytes

&n:w:!XlX:GX:1XQ

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Betrachten Sie als Beispiel die Eingabe

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

Der Code bildet &n:w:!Xlden Spaltenvektor [1; 2; 3; 4]und den Zeilenvektor [1 2 3 4 5]. Dann Xlberechnet die Mindestelementweise mit Broadcast, die die Matrix gibt

1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4

X:Linearisiert diese Matrix (in der Hauptreihenfolge der Spalten) in den Spaltenvektor [1; 1; 1; 1; 1; 2; 2; ... ; 4]. Dieser Vektor und die linearisierte Eingabematrix, erhalten als GX:, werden als Eingaben an die accumarray(... @sum)Funktion oder übergeben 1XQ. Dies berechnet die Summe der zweiten Eingabe, gruppiert nach den Werten der ersten Eingabe.

Gelee , 3 Bytes

ŒDS

Probieren Sie es online!

Wie es funktioniert

ŒDS

ŒD   diagonals
  S  vectorized sum

CJam , 23 18 Bytes

{[{(:+\z}h;]2/::+}

Anonymer Block, der das Argument auf dem Stapel erwartet und das Ergebnis auf dem Stapel belässt.

Probieren Sie es online!

Erläuterung

[      e# Begin working in an array.
 {     e#  Do:
  (:+  e#   Remove the first row of the matrix and sum it.
  \z   e#   Bring the matrix back to the top and transpose it.
 }h    e#  While the matrix is non-empty.
 ;     e#  Discard the remaining empty matrix.
]      e# Close the array.
2/     e# Split it into consecutive pairs of elements (possibly with a singleton on the end).
::+    e# Sum each pair.

05AB1E , 14 11 Bytes

[ćOˆøŽ]¯2ôO

Probieren Sie es online!

Erläuterung

[   Ž ]       # loop until stack is empty
 ć            # extract the head
  Oˆ          # sum and add to global list
     ø        # transpose
       ¯      # push global list
        2ô    # split into pairs
          O   # sum each pair

JavaScript (ES6), 60 Byte

a=>a.map((b,y)=>b.map((c,x)=>r[x=x<y?x:y]=~~r[x]+c),r=[])&&r

Naive Lösung, kann ein besserer Weg sein.

Mathematica, 60 Bytes

Inspiriert von Luis Mendos MATL-Antwort .

Pick[#,Min~Array~d,n]~Total~2~Table~{n,Min[d=Dimensions@#]}&

Erläuterung: Min~Array~Dimensions@#Erstellt eine Matrix wie die folgende:

1 1 1 1 1
1 2 2 2 2
1 2 3 3 3
1 2 3 4 4

Dann Pick[#,...,n]~Total~2nimmt die Einträge aus der Eingangsmatrix , die die Anzahl entspricht , nin der Matrix oben seltsamen und summiert sie. Endlich geht es ...~Table~{n,Min[d=Dimensions@#]}vorbei n.

Dies ist 1 Byte kürzer als der naive Ansatz:

{#[[n,n;;]],#[[n+1;;,n]]}~Total~2~Table~{n,Min@Dimensions@#}&

Haskell, 50 49 Bytes

f(a@(_:_):b)=sum(a++map(!!0)b):f(tail<$>b)
f _=[]

Probieren Sie es online!

Wenn es mindestens eine Zeile mit mindestens einem Element gibt, ist das Ergebnis die Summe der ersten Zeile und der Köpfe aller anderen Zeilen, gefolgt von einem rekursiven Aufruf mit den Endpunkten aller anderen Zeilen. In allen anderen Fällen ist das Ergebnis die leere Liste.

Edit: Ørjan Johansen hat ein Byte gespeichert. Vielen Dank!

Oktave , 64 52 Bytes

Vielen Dank an @StewieGriffin für das Speichern von 1 Byte!

@(x)accumarray(min((1:size(x))',1:rows(x'))(:),x(:))

Dies definiert eine anonyme Funktion.

Probieren Sie es online!

Erläuterung

Der Code ähnelt meiner MATL-Antwort (siehe Erklärung dort).

Es wurden zwei Bytes mit gespeichert, 1:size(x)anstatt 1:size(x,1)die Tatsache auszunutzen, die 1:[a b]sich genauso verhält wie 1:a. Auch ein Byte wurde mit gespeichert 1:rows(x')statt 1:size(x,2), dank Stewie.

k, 19 Bytes

|1_-':|+//'(1_+1_)\

Probieren Sie es online!

Erläuterung:

           (1_+1_)   /a function that strips the top and leftmost rows of a matrix
                  \  /apply this function as many times as possible,
                     /    saving each result as one element of a list
       +//'          /for each result, get the sum of all numbers
|  -':|              /subtract every right value from every left value
 1_                  /remove the extra 0

05AB1E , 16 Bytes

[ćOsø.g<NQ#])2ôO

Probieren Sie es online! oder Probieren Sie alle Tests aus

[                # Start loop
 ć               # Extract first element
  O              # Sum
   sø            # Transpose the input array (without the first N rows and columns)
     .g<NQ       # Push if (stack height - 1 == loop count)
          #]     # If they were equal break
            )2ô  # Break stack into chunks of 2
               O # Sum the chunks

Oktave , 63 60 Bytes

@(A)(@(L)sum(triu(A,1)')(L)+sum(tril(A))(L))(1:min(size(A)))

Probieren Sie es online!

Die Antwort für diese Matrix:

2   10   10    2    4
9    7    7    2    9
1    7    6    2    4
7    1    4    8    9

ist der Vektor der Zeilensummen seines oberen Dreiecks:

0   10   10    2    4
0    0    7    2    9
0    0    0    2    4
0    0    0    0    9

plus den Vektor der Spaltensummen des unteren Dreiecks:

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

Genau das ist meine Antwort.

Julia , 62 Bytes

f=x->1∈size(x)?sum(x):(n=f(x[2:end,2:end]);[sum(x)-sum(n);n])

Funktioniert rekursiv, indem die gesamte Matrix aufsummiert und dann die Summe des nächsten Blocks abgezogen wird. Wahrscheinlich nicht der effektivste Ansatz, aber schön intuitiv.

Java 7, 248 Bytes

String c(int[][]a){int l=a.length,L=a[0].length,b[][]=new int[l][L],i,j,x=1,s;for(;x<(l>L?l:L);x++)for(i=l;i-->x;)for(j=L;j-->x;b[i][j]=x);String r="";for(;x-->0;r=s>0?s+" "+r:r)for(s=0,i=0;i<l;i++)for(j=0;j<L;j++)s+=b[i][j]==x?a[i][j]:0;return r;}

Probieren Sie es hier aus.

Allgemeine Erklärung:

Angenommen, das Eingabearray hat Abmessungen von 4x6. Der erste Teil des Codes erstellt eine temporäre Matrix und füllt sie wie folgt:

// 1. Fill the entire array with 0:
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

// 2. Overwrite the inner part with 1 (excluding the first row & column):
0 0 0 0 0 0
0 1 1 1 1 1
0 1 1 1 1 1
0 1 1 1 1 1

// #. Etc. until we are left with this:
0 0 0 0 0 0
0 1 1 1 1 1
0 1 2 2 2 2
0 1 2 3 3 3

Und im zweiten Teil des Codes durchläuft es diese temporäre Matrix und summiert alle Werte der Eingabematrix für jede der unterschiedlichen Zahlen in der temporären Matrix.

Erklärung des Codes:

String c(int[][]a){               // Method with int-matrix parameter and String return-type
  int l=a.length,                 //  Amount of rows
      L=a[0].length,              //  Amount of columns
      b[][]=new int[l][L],        //  New temp matrix to fill as explained above
      i,j,x=1,s;                  //  Some temp integers

                                  //This is the first part of the code mentioned above:
  for(;x<(l>L?l:L);x++)           //  Loop (1) over the rows or columns (whichever is highest)
    for(i=l;i-->x;)               //   Inner loop (2) over the rows
      for(j=L;j-->x;              //    Inner loop (3) over the columns
        b[i][j]=x);               //     Set the current `x`-number
                                  //    End of loop (3) (implicit / no body)
                                  //   End of loop (2) (implicit / single-line body)
                                  //  End of loop (1) (implicit / single-line body)

                                  //This is the second part of the code mentioned above:
  String r="";                    //  Result-String
  for(;x-->0;                     //  Loop (4) over the unique numbers in the temp matrix
             r=s>0?s+" "+r:r)     //   After every iteration, append the sum to the result (if it's larger than 0)
    for(s=0,i=0;i<l;i++)          //   Inner loop (5) over the rows (and reset the sum to 0)
      for(j=0;j<L;j++)            //    Inner loop (6) over the columns
        s+=b[i][j]==x?a[i][j]:0;  //     Add to the sum if its position equals the current `x` in the temp matrix
                                  //    End of loop (6) (implicit / single-line body)
                                  //   End of loop (5) (implicit / single-line body)
                                  //  End of loop (4) (implicit / single-line body)
  return r;                       //  Return the result-String
}                                 // End of method

Perl 6 , 63 55 Bytes

{($_ Z [Z] $_).kv.map(->\a,\b{b.flatmap(*[a..*]).sum -b[0;a]})}

{($_ Z [Z] .skip).kv.map({$^b.flatmap(*[$^a..*]).sum})}

• $_ ist die Matrixeingabe für die anonyme Funktion
• .skip ist die Eingabematrix, deren erste Zeile entfernt wurde
• [Z] .skipist die Transponierte der Eingangsmatrix, wobei die erste Zeile entfernt ist; das heißt, die transponieren ohne ihre erste Spalte
• $_ Z [Z] .skip Zippt die Eingabematrix mit der Transponierten-ohne-Erste-Spalte und erstellt eine Liste ((first-row, first-column-sans-first-element), (second-row, second-column-sans-first-element), ...)
• .kv stellt jedem Paar seinen Index voran
• map({...})Ordnet die Paare mit einer Funktion zu, die ihr erstes Argument (den Index) $^aund ihr zweites (das Zeilen- / Spaltenpaar) übernimmt$^b
• $^b.flatmap(*[$^a..*]).sumEntfernt die ersten $^aElemente jedes Zeilen- / Spaltenpaares und summiert dann alle verbleibenden Elemente

Nach einiger Überlegung wurde mir klar, dass das Abziehen der ersten Spalte der Transponierten vor dem Zippen gleichbedeutend mit dem Subtrahieren der doppelt beitragenden diagonalen Elemente war, wie in meiner ersten Lösung. Dadurch konnte ich diese Subtraktion löschen und jedes Argument nur einmal für die Zuordnungsfunktion verwenden, was die {...$^a...$^b...}Methode zur Übergabe von Argumenten an eine anonyme Funktion effizienter machte als das Original -> \a, \b {...a...b...}.

Vim, 66 , 52 Bytes

qq^f j<C-v>}dkV}Jo<esc>p@qq@q:%s/\v> +</+/g|%norm C<C-v><C-r>=<C-v><C-r>"<C-v><cr><cr>

Probieren Sie es online!

Das falsche Werkzeug für den Job ...

Gelee , 10 Bytes

Ḣ;Ḣ€SṄȧßS¿

Ein vollständiges Programm, das die Werte druckt

Probieren Sie es online!

Wie?

Ḣ;Ḣ€SṄȧßF¿ - Main link: list of lists a
Ḣ          - head a (pop the first row and yield it, modifying a)
  Ḣ€       - head €ach (do the same for each of the remaining rows)
 ;         - concatenate
    S      - sum (adds up the list that contains the top row and left column)
     Ṅ     - print that plus a linefeed and yield the result
         ¿ - while:
           - ... condition:
        F  -   flatten (a list of empty lists flattens to an empty list which is falsey) 
           - ... body:
       ß   -   call this link with the same arity (as a monad) i.e. Main(modified a)
      ȧ    - logical and (when the sum is non-zero gets the modified a to feed back in)

Python + NumPy, 75 Byte

Die Eingabe ist ein 2D-Numpy-Array.

lambda L:[sum(L[i,i:])+sum(L[i+1:,i])for i in range(min(len(L),len(L[0])))]

Probieren Sie es online aus

Python 2 , 97 Bytes

f=lambda m:[reduce(lambda x,y:x+y[i],m[i:],sum(m[i][i+1:]))for i in range(min(len(m),len(m[0])))]

Probieren Sie es online!

Pyth, 16 15 Bytes

.es+>b+1k>@CQkk

Nimmt ein Array von Zahlen im Python-Stil und gibt ein Array von Summen zurück.

Versuch es!

Erläuterung

.es+>b+1k>@CQkk 
.e             Q  # Enumerated map over the implicit input (Q); indices k, rows b
           CQ     # Take the transpose
          @  k    # The kth column
         >    k   # cut off the first k elements
    >b+1k         # cut off the first k+1 elements of the rows, so (k,k) isn't counted twice
  s+              # add the row and column together and sum

GNU APL 1.7, 123 Bytes

Die Lösung erfordert zwei Funktionen: Eine erstellt ein globales Array und die zweite ruft das Array auf, wobei die Summen rekursiv an dieses Array angehängt werden.

∇f N
R←⍬
g N
R
∇
∇g N
→2+2×0∈⍴N
R←R,(+/N[1;])+(+/N[;1])-N[1;1]
g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]
∇

∇beginnt und beendet die Funktion. Beide fund gnehmen Tabellen als Argumente (im Wesentlichen 2D-Arrays). Diese können mit erstellt werden X←rows cols ⍴ 1 2 3 4....

R←⍬Weist der globalen Variablen einen leeren Vektor zu R.

g N ruft die zweite Funktion mit demselben Argument auf, das auch für die erste angegeben wurde.

⍴Ngibt die Dimensionen von N; Wenn eine der Dimensionen Null ist, müssen keine Zeilen / Spalten mehr addiert werden. 0∈⍴NGibt 1 zurück, wenn die Dimensionen eine Null enthalten. →2+2×0∈⍴Nverzweigt zu Zeile 2 plus 2 mal dem Rückgabewert der ∈Funktion: Wenn keine Null vorhanden ist, wird ∈0 zurückgegeben und die Funktion verzweigt zu Zeile 2 (der nächsten Zeile). Wenn es ist ein Null ist , ∈kehrt die Funktion 1 und verzweigt in Zeile 4 (das Ende der Funktion, also im returnWesentlichen).

/ist der Reduktionsoperator. Es wendet das linke Argument, das ein Operator ( +) ist, auf jedes Element in der Liste an, das als rechtes Argument angegeben ist. N[1;]gibt die gesamte erste Zeile der Tabelle und N[;1]die erste Spalte an. (+/N[1;])+(+/N[;1])-N[1;1]summiert die erste Zeile und Spalte und subtrahiert den Wert in der oberen linken Ecke, da er sowohl in der Spaltensumme als auch in der Zeilensumme addiert wird. R←R,...hängt den neu berechneten Wert an den globalen Vektor an R.

Die Funktion ruft sich dann selbst auf (solange rekursiv, bis keine Zeilen oder Spalten mehr vorhanden sind). Der ⊃Auswahloperator erhält das angegebene Element aus der Liste. 1⊃⍴Ngibt die Anzahl der Zeilen und 2⊃⍴Ndie Anzahl der Spalten an. ⍳gibt alle Zahlen von 1 bis zur angegebenen Zahl an. Der ↓Operator drop entfernt Elemente am Anfang der Liste. Wenn Sie beim Zugriff auf Elemente aus einer Tabelle oder einem Vektor (z. B. N[1 2 3]) mehrere Indizes angeben , greift APL auf jeden zu. Gibt daher 1↓⍳1⊃⍴Ndie Indizes jeder Zeile mit Ausnahme der ersten ( 2, 3, 4, ..., N) an und 1↓⍳2⊃⍴Ngibt einen ähnlichen Vektor mit Ausnahme der Spalten an. g N[1↓⍳1⊃⍴N;1↓⍳2⊃⍴N]ruft die Funktion erneut auf, jedoch ohne die erste Zeile oder Spalte.

PHP, 76 Bytes

<?foreach($_GET as$k=>$v)foreach($v as$n=>$i)$r[min($k,$n)]+=$i;print_r($r);

Probieren Sie es online!

Mathematica, 116 Bytes

l=Length;If[l@#==1||l@#[[1]]==1,Total@Flatten@#,Total/@Flatten/@Table[{#[[i]][[i;;]],#[[All,i]][[i+1;;]]},{i,l@#}]]&

Eingabeformular

[{{5}}], [{{1}, {4}}], [{{7,2}}] oder [{{....}, {....} ... {. ...}}]

Clojure, 98 Bytes

#(vals(apply merge-with +(sorted-map)(mapcat(fn[i r](map(fn[j v]{(min i j)v})(range)r))(range)%)))

Durchläuft die Eingabe mit Zeilen- und Spaltenindizes (sehr ausführlich), erstellt eine Hash-Map mit dem Minimum von iund führt jals Schlüssel Hash-Maps mit +einer sortierten Map zusammen und gibt Werte zurück.

R, 102 Bytes

function(x)`for`(i,1:min(r<-nrow(x),k<-ncol(x)),{dput(sum(x[,1],x[1,-1]));x=matrix(x[-1,-1],r-i,k-i)})

Gibt eine anonyme Funktion zurück. druckt die Ergebnisse mit einem nachgestellten Zeilenumbruch auf die Konsole. Ich brauche wahrscheinlich einen anderen Ansatz.

Iteriert über das Minimum der Zeilen und Spalten. Gibt die Summe aus x[,1](der ersten Spalte) und x[1,-1]der ersten Zeile mit Ausnahme des ersten Eintrags aus und setzt xdann eine Matrix gleich x[-1,-1](dh xohne die erste Zeile und Spalte). Leider führt das einfache Setzen dazu, x=x[-1,-1]dass es bei einer quadratischen Matrix fehlschlägt, da xdie Teilmenge bei 2x2 eher einen Vektor als eine Matrix zurückgibt.

Probieren Sie es online!

Java 7, 280 276 Bytes

import java.util.*;String d(ArrayList l){String r="";for(;l.size()>0&&((List)l.get(0)).size()>0;l.remove(0))r+=s(l)+" ";return r;}int s(List<ArrayList<Integer>>l){int s=0,L=l.size(),i=1;for(;l.get(0).size()>0;s+=l.get(0).remove(0));for(;i<L;s+=l.get(i++).remove(0));return s;}

Probieren Sie es hier aus.

Alternativer Ansatz im Vergleich zu meiner vorherigen Antwort mit Arrays, die am Ende immer noch kürzer ist als diese (also habe ich ein bisschen Zeit damit verschwendet, diesen alternativen Ansatz auszuprobieren).

Allgemeine Erklärung:

Inspiration von @Rileys erstaunlicher 05AB1E-Antwort
Diese Antwort verwendet eine Liste und entfernt nach Berechnung jeder Summe die erste Spalte und erste Zeile aus der Listenmatrix , wie folgt :

// Starting matrix:
7 10 1
4 4  2
6 3  4
1 4  10
5 7  6

// After first iteration (result so far: "34 "):
4  2
3  4
4  10
7  6

// After second iteration (result so far: "34 20 "):
4
10
6

// After last iteration, result: "34 20 20 "

Erklärung des Codes:

import java.util.*;                // Required import for List and ArrayList

String d(ArrayList l){             //  Method with ArrayList parameter and String return-type
  String r="";                     //  Return-String
  for(;l.size()>0&&((List)l.get(0)).size()>0; 
                                   //  Loop as long as the list still contains anything
       l.remove(0))                //  And remove the first row after every iteration
    r+=s(l)+" ";                   //   Append the sum to the result-String
                                   //  End of loop (implicit / single-line body)
  return r;                        //  Return result-String
}                                  // End of method

int s(List<ArrayList<Integer>>l){  // Separate method with List-matrix parameter and integer return-type
  int s=0,                         //  The sum
      L=l.size(),                  //  The size of the input list
      i=1;                         //  Temp integer
  for(;l.get(0).size()>0;          //  Loop (1) over the items of the first row
    s+=l.get(0).                   //   Add the number to the sum
                remove(0)          //   And remove it from the list afterwards
  );                               //  End of loop (1)
  for(;i<L;                        //  Loop (2) over the rows
    s+=l.get(i++).                 //   Add the first number of the row to the sum
                  remove(0)        //   And remove it from the list afterwards
  );                               //  End of loop (2)
  return s;                        //  Return sum
}                                  // End of separate method

Python, 93 Bytes

Ähnlich wie die Antwort von mbomb007, jedoch ohne NumPy

f=lambda m:[sum(m[k][k:])+sum(list(zip(*m))[k][k+1:])for k in range(min(len(m),len(m[0])))]