给定非空数字行的非空列表，请计算按列和，这是另一个具有最长输入行长度的列表。输出列表的第一个条目是输入行的所有第一个整数的总和，第二个是所有第二个元素的总和（如果有）等。我认为以下示例将对此进行更好的解释：

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]

测试用例

{[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]

果冻，1字节

S

在线尝试！或验证所有测试用例。

怎么运行的

和原子S是的简写+/，它通过加法执行归约。

快速/沿最大尺寸减小，因此它为输入的元素调用其链接。在这里，元素是行。

加法原子+矢量化，因此将两个行矢量相加会执行逐元素加法。当自变量具有不同的长度时，较长的自变量的元素在较短的自变量中没有对应元素，则这些元素将保持不变。

总而言之，以不规则矩阵作为参数，S计算列式总和，跳过较短行中丢失的条目。

Python 2中，47个 45字节

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

感谢@vaultah打高尔夫球2个字节！

在线尝试！

Perl 6、23个字节

{roundrobin(|$_)».sum}

Mathematica，15个字节

Total@*PadRight

Haskell，34个字节

import Data.List
map sum.transpose

在线尝试！用法：

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

CJam，7 5字节

多亏丹尼斯2个字节！

{:.+}

这定义了一个匿名块，该匿名块接受一个列表列表（例如）[[1 2 3 4] [1] [5 2 3] [6 1]]，然后将其替换为列表[13 5 6 4]。

在线尝试！或验证所有测试用例。

说明

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

MATL，3个字节

oXs

（MATL不知道“ ox”的复数是“ oxen” ...）

输入是数字行向量的单元格数组，格式与质询文本相同：

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

在线尝试！或验证所有测试用例。

     % 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字节

由于ETHproductions节省了3个字节

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

测试用例

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]

不可思议，11个字节

@->#sum '#0

用求和功能进行转置和映射。用法：

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

C ++ 14，130字节

作为未命名的通用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();}

要求C要像vector<vector<int>>和返回值r是像vector<int>（应根据没事元）。

脱胶和用法：

#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个字节

sM.T

在这里在线尝试。

Haskell，61 41 40字节

感谢@Laikoni提供-20个字节，@ nimi提供-1个字节！

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

说明：这只是列表中第一个元素的递归求和，还涉及在每个中间步骤中丢弃空列表：

    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个字节

+/@:>

将输入作为列表的装箱列表。

测试用例

   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 个字节

+⌿↑

+⌿ 按列求和

↑ 混合（列表的列表，堆叠到矩阵中，用零填充）参数

在线尝试APL！

Pyke，4个字节

.,ms

在这里尝试！

Java 8，124字节

这是一个lambda表达式 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;}

它从输入中获取最大的数组长度，创建一个具有该大小的新数组，然后将每一列的总和写入该数组。

八度，69字节

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

R，105 97字节

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)

这输入一个list名为的对象w，形式为：

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

它输出按列求和： [1] 3 4 3 4

这个解决方案对我来说很长。当您尝试绑定不同长度的向量时，R具有回收的特殊性。例如 ：

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 被重新使用一次以适应，这就是为什么我从列表开始。

该程序将列表中所有元素的长度调整为最长的一个，绑定元素并计算按列求和。长度调整产生NA的，被忽略sum。

-8个字节，感谢@Jarko Dubbeldam！

PHP，63字节

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

在浏览器中使用GET参数作为输入列表进行调用。

示例：（
script.php?a[]=1&a[]=2&a[]=3&a[]=4&b[]=1&c[]=5&c[]=2&c[]=3&d[]=6&d[]=1
数组名称将被忽略，因此您可以根据需要使用任何名称。）

尝试使用此功能进行测试：

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

或用于http_build_query($array,a)将给定的数组转换为GET参数。

Clojure，70个字节

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

一个基本的嵌套循环。

Japt，5个字节

Uz mx

在线测试！

U是输入数组，z在数组上，将数组顺时针旋转90度。因此，

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

变成

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

（添加空格仅用于显示目的。）

mx然后m通过求和（x）进行aps ，得到所需结果：[13,5,6,4]。