Nehmen Sie eine Matrix positiver Ganzzahlen als Eingabe und geben Sie die einzelnen Summen der Elemente auf den diagonalen Linien durch die Matrix aus.

Sie sollen nur die Linien zählen, die diagonal nach unten und rechts verlaufen. Sie müssen mit der Diagonale beginnen, die nur das untere linke Element enthält, dann mit der Diagonale der Länge zwei darüber (falls vorhanden) und so weiter bis zu der Diagonale, die nur das obere rechte Element enthält, wie unten dargestellt.

Beispiel:

Input:
 8   14    5    1
10    5    5    8
 6    6    8   10
15   15    4   11

Output:
15, 21, 20, 32, 29, 13, 1
(Diagonals: {{15},{6,15},{10,6,4},{8,5,8,11},{14,5,10},{5,8},{1}})

Input:
1
Output:
1

Input: 
1 5
Output:
1, 5

Input:
4
1

Output: 
1, 4

Input:
17    4    5
24   16    5
 9   24   10
 1   14   22
 1   21   24
 4    4   17
24   25   17

Output:
24, 29, 22, 39, 47, 70, 43, 9, 5

Eingabe- und Ausgabeformate sind wie immer optional.

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

Haskell , 40 37 Bytes

z=0:z
foldl1$(.(++z)).zipWith(+).(0:)

Probieren Sie es online! Verbrauch: (foldl1$(.(++z)).zipWith(+).(0:)) [[1,2,3],[4,5,6]].

Edit: Danke an Ørjan Johansen für -3 Bytes!

Ungolfed:

z = 0:z
s#t = zipWith(+)(0:s)(t++z)
f m = foldl1 (#) m

zist eine Liste mit unendlich vielen Nullen. In fklappen wir die Liste der Listen mum, indem wir zwei Listen mit der Funktion kombinieren #. In #der ersten Liste ssind die akkumulierten Spaltensummen enthalten und in der zweiten Liste tist die neue Zeile, die hinzugefügt werden soll. Wir verschieben sein Element nach rechts, indem wir vorne eine Null hinzufügen sund elementweise addieren und tmit zipWith(+). Da ses beliebig groß sein kann, müssen wir tdurch Anhängen genügend Nullen auffüllen z.

Mathematica, 53-54 Bytes

l=Length@#-1&;Tr@Diagonal[#,k]~Table~{k,-l@#,l@#&@@#}&

Reine Funktion, die ein 2D-Array als Eingabe verwendet und eine Liste zurückgibt. (Einträge müssen keine ganzen oder geraden Zahlen sein.) Diagonal[#,k]Gibt die kth-Diagonale über (oder unter, falls knegativ) der Hauptdiagonale zurück. {k,-l@#,l@#&@@#}Berechnet den Bereich der benötigten Diagonalen basierend auf den Abmessungen des Eingabearrays. Und Trsummiert die Einträge jeder Diagonale.

MATL , 6 Bytes

T&XdXs

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

Erläuterung

T&Xd   % All diagonals of implicit input arranged as zero-padded columns
Xs     % Sum of each column. Implicitly display

Gelee , 5 Bytes

0;+µ/

Probieren Sie es online!

Wie es funktioniert

0;+µ/  Main link. Argument: M (matrix / array of rows)

   µ   Combine all links to the left into a chain (arity unknown at parse time) and
       begin a new monadic chain.
    /  Reduce M by that chain. This makes the chain dyadic.
       Let's call the arguments of the chain L and R (both flat arrays).
0;         Prepend a 0 to L.
  +        Perform element-wise addition of the result and R.
           When the chain is called for the n-th time, R has n less elements, so
           the last n elements of L won't have matching elements in R and will be
           left unaltered.

JavaScript (ES6), 65 58 Bytes

a=>a.map(b=>b.map((c,i)=>r[i]=~~r[i]+c,r=[,...r]),r=[])&&r

CJam , 22 21 Bytes

Dank Martin Ender 1 Byte gespeichert

{_,({0\f+}*ee::m<:.+}

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

Probieren Sie es online!

Wie es funktioniert

_                   e# Duplicate the matrix
 ,(                 e# Get its length (# of rows) minus 1
   {0\f+}*          e# Prepend that many 0s to each row
          ee        e# Enumerate; map each row to [index, row]
            ::m<    e# Rotate each row left a number of spaces equal to its index
                :.+ e# Sum each column

05AB1E , 17 Bytes

Rvy¹gÅ0«NFÁ}})øO¨

Probieren Sie es online!

Erläuterung

R                  # reverse input
 v                 # for each N,y (index, item)
  y¹gÅ0«           # pad y with as many zeroes as the number of rows in the input
        NFÁ}       # rotate each row N times right
            })     # wrap the result in a list
              øO   # sum the columns
                ¨  # remove the last element of the resulting list (the padded zeroes)

J , 7 Bytes

+//.@|.

Probieren Sie es online!

Das ist ziemlich einfach:

+//.@|.
+/        sum
  /.      on oblique lines
    @|.   on the reversed array

Schräge umgekehrte Linien sind die Diagonalen des Arrays. Dies summiert also nur die Diagonalen.

Python 2 , 62 Bytes

lambda M:reduce(lambda x,y:map(sum,zip([0]+x,y+[0]*len(x))),M)

Probieren Sie es online!

Gelee , 8 Bytes

ŒDS€ṙZL$

Probieren Sie es online!

Die Hälfte des Codes wird verwendet, um die Ergebnisse in die richtige Reihenfolge zu bringen.

Wie?

ŒDS€ṙZL$ - Main link: list of lists of numbers
ŒD       - diagonals (starts with the diagonal containing the top left element,
         -            then the next diagonal to the right, and so on wrapping around)
  S€     - sum €each
       $ - last two links as a monad
     Z   - transpose the matrix
      L  - length (width of the matrix)
    ṙ    - rotate the results left by that amount

Perl 5, 47 Bytes

map{$j=--$.;map{@a[$j++]+=$_}split}<>
print"@a"

R, 45 Bytes

Unbenannte Funktion, die ein Objekt der Matrixklasse als Eingabe verwendet:

function(x)sapply(split(x,col(x)-row(x)),sum)

Unter Verwendung der in dieser Antwort erläuterten Idee .

Oktave, 71 Bytes

Angenommen, A ist eine Matrix, zum Beispiel:

A = [17 4 5;24 16 5; 9 24 10; 1 14 22; 1 21 24; 4 4 17;24 25 17];

Dann haben wir:

[m,n]=size(A);
a=[zeros(m,m-1),A]';
for i=1:m+n-1
trace(a(i:end,:))
end

Beachten Sie, dass das Vertauschen der Matrix die Reihenfolge der diagonalen Summen umkehrt, wodurch insgesamt zwei Bytes in der for-Schleife gespeichert wurden.

Ausgabe:

ans =  24
ans =  29
ans =  22
ans =  39
ans =  47
ans =  70
ans =  43
ans =  9
ans =  5

Python, 126 Bytes

x=input()
f=lambda k:[x[i+k][i]for i in range(len(x)-k)]
a=map(f,range(4)[::-1])
x=zip(*x)
print(map(sum,a+map(f,range(1,4))))

fFunktioniert nur auf dem unteren Dreiecksabschnitt, also transponiere ich ihn und erhalte den oberen Dreiecksabschnitt auf diese Weise. Ich weiß nicht, warum die fFunktion für negative Werte nicht funktioniert (ich fhabe sie kürzer gewählt, weil der Teil zum Abrufen der Negative nicht funktioniert hat).

C 148 Bytes

Versuchen Sie es online

s;g(int i,int j,int**m,int x){for(s=0;x;x--)s+=m[i++][j++];printf(" %d",s);}
k;f(int n,int**m){for(k=n;--k;)g(k,0,m,n-k);for(;k<n;k++)g(0,k,m,n-k);}

PHP, 81 Bytes

Eingabe als 2D-Array übernehmen

<?foreach($_GET as$k=>$v)foreach($v as$x=>$y)$r[$x-$k]+=$y;ksort($r);print_r($r);

Probieren Sie es online!

Awk, 67 Bytes

{for(f=0;f++<NF;)s[NF-NR+f]+=$f}END{i=0;while(i++<NR*2)print s[i]}

Ungolfed:

{
    for (f = 0; f++ < NF;)
        s[NF-NR+f] += $f
}
END {
    i = 0
    while (i++ < NR*2)
        print s[i]
}

Awk-Splits auf Whitespace $nsind das nth-Feld (1-indiziert); NFist die Anzahl der Felder in der Zeile, NRist die Nummer der aktuellen Zeile. Undefinierte Variablen sind 0 und werden bei der ersten Verwendung erstellt.

PHP, 86 Bytes

eine speicherfreundliche Lösung in zwei Varianten:

<?for($i=$c=count($a=$_GET);--$i>-$c;print$s._)for($s=0,$d=$c;$d--;)$s+=$a[$i+$d][$d];
<?for($i=$c=count($a=$_GET);--$i>-$c;print$s._)for($s=$d=0;$d<$c;)$s+=$a[$i+$d][$d++];

Nimmt Eingaben von Skriptparametern entgegen und verwendet den Unterstrich als Trennzeichen.
verwende die Standardeinstellungen (nicht die Standard-php.ini) oder versuche sie online

Clojure, 81 Bytes

#(apply map +(map(fn[i c](concat(repeat(-(count %)i 1)0)c(repeat i 0)))(range)%))

Sehr ausführlich, da Listen mit Nullen aufgefüllt werden, sodass wir nur die spaltenweise Summe berechnen können.

Mathematica 73 Bytes

Plus@@@Table[Diagonal[Partition[#1,#2[[1]]],k],{k,-#2[[2]]+1,#2[[1]]-1}]&

Dies funktioniert für JEDES 2D-Array. Mxn (nicht nur nxn) gibt
das Array am Ende des Codes wie folgt ein (der letzte Testfall)

[{17,4,5,24,16,5,9,24,10,1,14,22,1,21,24,4,4,17,24,25,17},{3,7}]

{24, 29, 22, 39, 47, 70, 43, 9, 5}

Eingabe in Form [{a, b, c, d ...}, {m, n}]