비어 있지 않은 숫자의 행으로 구성된 비어 있지 않은 목록이 주어지면, 열 단위의 sum을 계산하십시오 . 이는 가장 긴 입력 행의 길이를 갖는 또 다른 목록입니다. 출력 목록의 첫 번째 항목은 입력 행의 모든 ​​첫 번째 전체의 합이고 두 번째 항목은 모든 두 번째 요소 (사용 가능한 경우)의 합입니다. 다음 예제는 더 잘 설명 할 것이라고 생각합니다.

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하면 열 단위 합계를 계산하여 짧은 행에서 누락 된 항목을 건너 뜁니다.

파이썬 2 , 47 45 바이트

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

2 바이트를 골라 낸 @vaultah에게 감사드립니다!

온라인으로 사용해보십시오!

펄 6 , 23 바이트

{roundrobin(|$_)».sum}

Mathematica, 15 바이트

Total@*PadRight

하스켈, 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 바이트

Dennis 덕분에 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

자바 스크립트 (ES6), 51 48 바이트

ETH 프로덕션 덕분에 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]

Wonder , 11 바이트

@->#sum '#0

합계 기능으로 전치 및 매핑 용법:

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

C ++ 14, 130 바이트

명명되지 않은 일반 람다로 :

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

여기에서 온라인으로 사용해보십시오 .

하스켈, 61 41 40 바이트

-20 바이트의 경우 @Laikoni, -1 바이트의 경우 @nimi에게 감사합니다!

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 바이트

+⌿↑

+⌿ 열 단위로 합계

↑ 혼합 된 (리스트의 목록, 행렬로 쌓이고 0으로 채워짐) 인수

TryAPL 온라인!

파이크, 4 바이트

.,ms

여기 사용해보십시오!

자바 8, 124 바이트

이것은에 대한 람다 식입니다 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 .

@Jarko Dubbeldam 덕분에 -8 바이트 !

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 매개 변수로 변환하는 데 사용 합니다.

클로저, 70 바이트

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

기본 중첩 루프.

apt, 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].