Đưa ra một danh sách không trống của các hàng số không trống, tính tổng số khôn ngoan của cột , đó là một danh sách khác có độ dài của hàng đầu vào dài nhất. Mục nhập đầu tiên của danh sách đầu ra là tổng của tất cả các mục nhập đầu tiên của các hàng đầu vào, mục thứ hai là tổng của tất cả các phần tử thứ hai (nếu có), v.v ... Tôi nghĩ ví dụ sau sẽ giải thích nó tốt hơn:

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]

Các trường hợp thử nghiệm

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

Thạch , 1 byte

S

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

Nguyên tử tổng Slà một tốc ký +/, thực hiện khử bằng phép cộng.

Nhanh chóng /giảm dọc theo chiều ngoài cùng, vì vậy nó gọi liên kết của nó cho các yếu tố của đầu vào. Ở đây, các yếu tố là các hàng.

Nguyên tử +bổ sung vectơ hóa, vì vậy việc thêm hai vectơ hàng thực hiện phép cộng từng phần tử. Khi các đối số có độ dài khác nhau, các phần tử của đối số dài hơn không có đối tác trong phần đối số ngắn hơn sẽ không được thay đổi.

Nói chung, với một ma trận bất quy tắc làm đối số, Stính tổng của cột, bỏ qua các mục bị thiếu trong các hàng ngắn hơn.

Python 2 , 47 45 byte

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

Cảm ơn @vaultah vì đã chơi golf 2 byte!

Hãy thử trực tuyến!

Perl 6 , 23 byte

{roundrobin(|$_)».sum}

Toán học, 15 byte

Total@*PadRight

Haskell, 34 byte

import Data.List
map sum.transpose

Hãy thử trực tuyến! Sử dụng:

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

CJam , 7 5 byte

Giảm 2 byte nhờ Dennis!

{:.+}

Điều này xác định một khối ẩn danh có một danh sách các danh sách, chẳng hạn như [[1 2 3 4] [1] [5 2 3] [6 1]], và thay thế nó bằng một danh sách , [13 5 6 4].

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

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

MATL , 3 byte

oXs

( MATL không biết rằng số nhiều của "ox" là "oxen" ... )

Đầu vào là một mảng ô của các vectơ hàng số, có cùng định dạng như trong văn bản thách thức:

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

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

     % 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 byte

Đã lưu 3 byte, nhờ vào ETHproductions

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

Các trường hợp thử nghiệm

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]

Kỳ quan , 11 byte

@->#sum '#0

Chuyển vị và bản đồ với hàm tổng. Sử dụng:

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

C ++ 14, 130 byte

Như lambda chung chưa được đặt tên:

[](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();}

Yêu cầu Cđược like vector<vector<int>>và trả về giá trị rđể được like vector<int>(nên ổn theo meta ).

Ungolfed & cách sử dụng:

#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 byte

sM.T

Hãy thử trực tuyến tại đây .

Haskell, 61 41 40 byte

Cảm ơn @Laikoni cho -20 byte, @nimi cho -1 byte!

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

Giải thích: Đây chỉ là một bản tóm tắt đệ quy của các yếu tố đầu tiên của danh sách, cũng xử lý loại bỏ danh sách trống trong mỗi bước trung gian:

    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 byte

+/@:>

Đưa đầu vào như một danh sách đóng hộp của danh sách.

Các trường hợp thử nghiệm

   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

APL Dyalog , 3 byte

+⌿↑

+⌿ tổng cột

↑ đối số hỗn hợp (danh sách danh sách, xếp chồng thành ma trận, đệm với số không)

Dùng thử trực tuyến!

Pyke, 4 byte

.,ms

Hãy thử nó ở đây!

Java 8, 124 byte

đây là một biểu thức lambda cho một 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;}

nó lấy chiều dài mảng lớn nhất từ ​​đầu vào, tạo một mảng mới có kích thước đó và sau đó ghi tổng của từng cột vào mảng.

Octave, 69 byte

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

R, 105 97 byte

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)

Điều này nhận đầu vào một listđối tượng được gọi wtrong biểu mẫu:

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

Nó xuất ra tổng số theo cột: [1] 3 4 3 4

Giải pháp này khá dài đối với tôi. R có tính đặc biệt để tái chế khi bạn cố gắng liên kết các vectơ có độ dài khác nhau. Ví dụ :

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 được sử dụng lại một lần cho phù hợp, đó là lý do tại sao tôi bắt đầu với một danh sách.

Chương trình điều chỉnh độ dài của tất cả các phần tử của danh sách là một trong những phần tử dài nhất, liên kết các phần tử và tính tổng của cột. Việc điều chỉnh độ dài tạo ra NA, được bỏ qua bởi sum.

-8 byte nhờ @Jarko Dubbeldam!

PHP, 63 byte

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

gọi trong trình duyệt với các tham số GET là danh sách các đầu vào.

Ví dụ:
script.php?a[]=1&a[]=2&a[]=3&a[]=4&b[]=1&c[]=5&c[]=2&c[]=3&d[]=6&d[]=1
(Tên mảng bị bỏ qua, vì vậy bạn có thể đặt tên theo bất kỳ cách nào bạn muốn.)

Hãy thử chức năng này để kiểm tra:

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

hoặc sử dụng http_build_query($array,a)để chuyển đổi một mảng các mảng nhất định thành các tham số GET.

Clojure, 70 byte

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

Một vòng lặp lồng cơ bản.

Japt, 5 byte

Uz mx

Kiểm tra nó trực tuyến!

Ulà mảng đầu vào và ztrên các mảng xoay mảng theo chiều kim đồng hồ 90 độ. Vì thế,

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

trở thành

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

(Khoảng cách chỉ được thêm cho mục đích hiển thị.)

mxsau đó maps bằng phép tính tổng ( x), cho kết quả mong muốn : [13,5,6,4].