Berechnen Sie bei einer nicht leeren Liste mit nicht leeren Zahlenzeilen die spaltenweise Summe . Dies ist eine weitere Liste mit der Länge der längsten Eingabezeile. Der erste Eintrag in der Ausgabeliste ist die Summe aller ersten Einträge der Eingabezeilen, der zweite ist die Summe aller zweiten Elemente (falls verfügbar) usw. Ich denke, das folgende Beispiel wird es besser erklären:

Input:      {[1,2,3,4],[1],[5,2,3],[6,1]}
Computation: [1,2,3,4]
              + . . .
             [1]. . .
              + + + .
             [5,2,3].
              + + . .
             [6,1]. .
              = = = =
    Output: [13,5,6,4]

Testfälle

{[0]}                         -> 0
{[1],[1,1,1,1]}               -> [2,1,1,1]
{[1],[1,2],[1,2,3],[1,2,3,4]} -> [4,6,6,4]
{[1,6,2,-6],[-1,2,3,5]}       -> [0,8,5,-1]

Gelee , 1 Byte

S

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

Wie es funktioniert

Das Summenatom Sist eine Abkürzung für +/, die durch Addition eine Reduktion durchführt.

Der Schnellzugriff /wird entlang der äußersten Dimension reduziert, sodass die Verknüpfung für die Elemente der Eingabe aufgerufen wird. Hier sind die Elemente die Zeilen.

Das Additionsatom +vektorisiert, so dass das Addieren von zwei Zeilenvektoren eine elementweise Addition durchführt. Wenn die Argumente unterschiedlich lang sind, bleiben die Elemente des längeren Arguments, die kein Gegenstück zum kürzeren haben, unverändert.

Insgesamt wird mit einer unregelmäßigen Matrix als Argument Sdie spaltenweise Summe berechnet, wobei fehlende Einträge in den kürzeren Zeilen übersprungen werden.

Python 2 , 47 45 Bytes

lambda x:map(lambda*y:sum(filter(None,y)),*x)

Vielen Dank an @vaultah für das Golfen mit 2 Bytes!

Probieren Sie es online!

Perl 6 , 23 Bytes

{roundrobin(|$_)».sum}

Mathematica, 15 Bytes

Total@*PadRight

Haskell, 34 Bytes

import Data.List
map sum.transpose

Probieren Sie es online! Verwendung:

Prelude Data.List> map sum.transpose $ [[1,2,3,4],[1],[5,2,3],[6,1]]
[13,5,6,4]

CJam , 7 5 Bytes

2 Bytes weniger dank Dennis!

{:.+}

Dies definiert einen anonymen Block, der eine Liste von Listen aufnimmt, z. B. [[1 2 3 4] [1] [5 2 3] [6 1]]und diese durch eine Liste ersetzt [13 5 6 4].

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

Erläuterung

{   }   e# Define block
 :      e# Fold over the following dyadic function
  .+    e# Vectorized addition

MATL , 3 Bytes

oXs

( MATL weiß nicht, dass der Plural von "ox" "oxen" ist ... )

Die Eingabe ist ein Zellenarray numerischer Zeilenvektoren im gleichen Format wie im Aufforderungstext:

{[1,2,3,4],[1],[5,2,3],[6,1]}

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

     % Implicit input
o    % Convert cell array to a matrix, right-padding with zeros each row
Xs   % Sum of each column
     % Implicit display

JavaScript (ES6), 51 48 Bytes

Dank ETHproductions 3 Bytes gespart

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

Testfälle

let f =

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

console.log(f([[1,2,3,4],[1],[5,2,3],[6,1]])); // -> [13,5,6,4]
console.log(f([[0]]));                         // -> [0]
console.log(f([[1],[1,1,1,1]]));               // -> [2,1,1,1]
console.log(f([[1],[1,2],[1,2,3],[1,2,3,4]])); // -> [4,6,6,4]
console.log(f([[1,6,2,-6],[-1,2,3,5]]));       // -> [0,8,5,-1]

Wunder , 11 Bytes

@->#sum '#0

Transponieren und Mapen mit Summenfunktion. Verwendung:

(@->#sum '#0)[[1 2 3 4];[1];[5 2 3];[6 1]]

C ++ 14, 130 Bytes

Als unbenanntes generisches Lambda:

[](auto C,auto&r){r.clear();int i=0,b=1;while(b--){r.push_back(0);for(auto c:C)r.back()+=i<c.size()?c[b=1,i]:0;++i;}r.pop_back();}

Erfordert C, wie zu sein, vector<vector<int>>und Rückgabewert r, um wie zu sein vector<int>(sollte laut Meta in Ordnung sein ).

Ungolfed & Nutzung:

#include<vector>
#include<iostream>

auto f=
[](auto C, auto&r){
 r.clear();         //clearing r just to be sure
 int i=0,b=1;       //i is the position in the row, b is a boolean
 while(b--){        //while something was added
  r.push_back(0);   //add zero
  for(auto c:C)     //for each container
   r.back() += i<c.size() ?   //add to the last element 
    c[b=1,i] : 0;             //set b and get the element or zero 
  ++i;              
 }
 r.pop_back();      //remove last unnecessary zero
}
;

using namespace std;

int main(){
 vector<vector<int> > C = { {1,2,3,4}, {1}, {5,2,3}, {6,1} };
 vector<int> r; 
 f(C,r);
 for (int i: r)
  cout << i << ", ";
 cout << endl;
}

Pyth - 4 Bytes

sM.T

Probieren Sie es hier online aus .

Haskell, 61 41 40 Bytes

Danke @Laikoni für -20 Bytes, @nimi für -1 Bytes!

f[]=[]
f l=sum[h|h:_<-l]:f[t:u|_:t:u<-l]

Erläuterung: Es handelt sich nur um eine rekursive Zusammenfassung der ersten Elemente der Liste, die auch das Löschen leerer Listen in jedem Zwischenschritt behandelt:

    sum[h|h:_<-l]                    -- sums up all the first elemetns of the list
                    [t:u|_:t:u<-l]   -- removes the first element of all the list, and removes empty lists
                   f                 -- applies f to the remaining list
                 :                   -- prepends the sum to the rest

J, 5 Bytes

+/@:>

Nimmt die Eingabe als eine Liste von Listen in Kästchen an.

Testfälle

   1 ; 1 1 1 1
+-+-------+
|1|1 1 1 1|
+-+-------+
   (+/@:>) 1 ; 1 1 1 1
2 1 1 1
   1 ; 1 2 ; 1 2 3 ; 1 2 3 4
+-+---+-----+-------+
|1|1 2|1 2 3|1 2 3 4|
+-+---+-----+-------+
   (+/@:>) 1 ; 1 2 ; 1 2 3 ; 1 2 3 4
4 6 6 4

Dyalog APL , 3 Bytes

+⌿↑

+⌿ Summe spaltenweise

↑ das gemischte Argument (Liste der Liste, in Matrix gestapelt, mit Nullen aufgefüllt)

TryAPL online!

Pyke, 4 Bytes

.,ms

Probieren Sie es hier aus!

Java 8, 124 Bytes

Dies ist ein Lambda-Ausdruck für a Function< int[ ][ ], int[ ] >

i->{int L=0,t,r[];for(int[]a:i)L=(t=a.length)>L?t:L;r=new int[L];for(;0>L--;)for(int[]a:i)r[L]+=a.length>L?a[L]:0;return r;}

Es nimmt die größte Array-Länge von der Eingabe, erstellt ein neues Array dieser Größe und schreibt dann die Summen jeder Spalte in das Array.

Oktave, 69 Bytes

@(a){g=1:max(s=cellfun(@numel,a))<=s';f=g'+0;f(g')=[a{:}];sum(f')}{4}

R 105 97 Bytes

a=c();l=length;for(i in 1:l(w)){length(w[[i]])=max(sapply(w,l));a=rbind(a,w[[i]])};colSums(a,n=T)

Dies nimmt in der Eingabe ein listObjekt auf, das win der Form aufgerufen wird:

w=list(c(1,2,3,4),c(1),c(1,2))

Es gibt die spaltenweise Summe aus: [1] 3 4 3 4

Diese Lösung ist mir ziemlich lang. R hat die Besonderheit, recycelt zu werden, wenn Sie versuchen, Vektoren unterschiedlicher Länge zu binden. Beispielsweise :

a=c(1,2,3,4)
b=c(1,2)

cbind(a,b)

     a b
[1,] 1 1
[2,] 2 2
[3,] 3 1
[4,] 4 2

b wird zur Anpassung einmalig wiederverwendet, weshalb ich mit einer Liste beginne.

Das Programm passt die Länge aller Elemente der Liste als die der längsten an, bindet die Elemente und berechnet die spaltenweise Summe. Die Längenanpassung erzeugt NA's, die von der ignoriert werden sum.

-8 Bytes dank @Jarko Dubbeldam!

PHP, 63 Bytes

<?foreach($_GETas$a)foreach($a as$i=>$x)$r[$i]+=$x;print_r($r);

Browser mit GET-Parametern als Liste der Eingaben aufrufen.

Beispiel:
script.php?a[]=1&a[]=2&a[]=3&a[]=4&b[]=1&c[]=5&c[]=2&c[]=3&d[]=6&d[]=1
(Array-Namen werden ignoriert, sodass Sie sie nach Belieben benennen können.)

Probieren Sie diese Funktion zum Testen aus:

function s($a){foreach($a as$b)foreach($b as$i=>$x)$r[$i]+=$x;return$r;}

oder verwenden Sie http_build_query($array,a), um ein bestimmtes Array von Arrays in GET-Parameter zu konvertieren.

Clojure, 70 Bytes

#(for[i(range(apply max(map count %)))](apply +(for[v %](get v i 0))))

Eine einfache verschachtelte Schleife.

Japt, 5 Bytes

Uz mx

Online testen!

Uist das Eingabearray, und zbei Arrays wird das Array im Uhrzeigersinn um 90 Grad gedreht. Deshalb,

[
 [1,2,3,4],
 [1      ],
 [5,2,3  ],
 [6,1    ]
]

wird

[
 [6,5,1,1],
 [1,2,  2],
 [  3,  3],
 [      4]
]

(Abstand nur zu Anzeigezwecken hinzugefügt.)

mxdann maps durch Summierung ( x), die das gewünschte Ergebnis liefert: [13,5,6,4].