Summiere die Diagonalen


19

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 , also gewinnt die kürzeste Einsendung in jeder Sprache.


Antworten:


6

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.


Das ist kürzer Punkt frei: foldl1$(.(++z)).zipWith(+).(0:).
Ørjan Johansen

6

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.


Alternative bei gleicher Byteanzahl, aber vielleicht können Sie weiter Golf spielen? Diese Klammern sehen schlecht aus. Tr@Diagonal[m,#]&/@Range@@({-1,1}(Dimensions[m=#]-1))&
Martin Ender

5

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

Nur neugierig: Glauben Sie, dass es insgesamt besser wäre, sich s==sum(x(:))an die MATLAB-Konvention zu halten, als es MATL zu tun scheint?
Stewie Griffin

@StewieGriffin Ich habe manchmal darüber nachgedacht. Mein Zweifel war mehr zwischen sum(x)und sum(x,1). Bei einer Matrix ist es manchmal ärgerlich x, dass sie sum(x)sich anders verhält, wenn die Matrix eine Zeile enthält. Aber am Ende habe ich mich für Matlab entschieden, damit die beiden Sprachen näher zusammenkommen. und einige fun(x,1)Funktionen für die häufigsten Fälle hinzufügen
Luis Mendo

5

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.

Nur das erste R, das reduziert, hat ein Element weniger. es erhöht sich um ein weiteres Element pro Zeile.
Ørjan Johansen

Das ist nur schlau ... nein ŒD?
Erik der Outgolfer

@EriktheOutgolfer Wieder einmal ŒDverhinderte die seltsame Reihenfolge, dass es nützlich war.
Dennis

@ Dennis Dann denke ich , dass ich etwas machen würde , die nicht so seltsam Ordnung hat ... oh, vielleicht 3 Monaden könnte eingehenden sein.
Erik der Outgolfer

5

JavaScript (ES6), 65 58 Bytes

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

63-Byte-Variante:a=>a.map(r=>r.map(v=>s[i]=~~s[i++]+v,i=--y),s=[],y=a.length)&&s
Arnauld

@Arnauld Ich stimme zu, das Rückwärtsfahren war ein schlechter Zug. Aber die Länge zu nehmen ist auch zu lang!
Neil

3

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

2

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)

2

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.



1

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

1

Perl 5, 47 Bytes

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

1

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 .


Ich glaube, die Regeln in dieser Herausforderung ermöglichen es Ihnen, den Anruf an loszuwerden unname, aber dies ist trotzdem eine großartige Lösung!
Giuseppe

1

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

1
[m,n]=size(A);for i=1:m+n-1,trace([zeros(m-1,m);A'](i:end,:)),endSpart 6 Bytes. Octave kann direkte Indizierungen und Inline-Zuweisungen durchführen. Leider unter der Annahme, dass eine Variable exist in den Arbeitsraum vor dem Ausführen des Codes ist nicht zulässig, so dass ich glaube , Sie verwenden müssen input, wie dies auf 75 Bytes sichern zu bringen. Netter Ansatz, also +1 von mir :) Und willkommen bei PPCG! =)
Stewie Griffin

Auch zeros(m-1,m)kann geschrieben werden ~e(m-1,m), Einsparung von 4 Bytes :) Ordentlich nicht wahr?
Stewie Griffin

0

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


Ich erhalte einen Fehler für den letzten Testfall. tio.run/nexus/…
Dennis

0

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);}


0

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.


0

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


0

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.


0

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}]

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.