Dato un elenco non vuoto di righe di numeri non vuoti, calcolare la somma saggia della colonna , che è un altro elenco che ha la lunghezza della riga di input più lunga. La prima voce dell'elenco di output è la somma di tutti i primi entires delle righe di input, la seconda è la somma di tutti i secondi elementi (se disponibili) ecc. Penso che l'esempio seguente spiegherà meglio:

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]

Casi test

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

Gelatina , 1 byte

S

Provalo online! o verifica tutti i casi di test .

Come funziona

L'atomo somma Sè una scorciatoia per +/, che esegue la riduzione per addizione.

Il rapido si /riduce lungo la dimensione più esterna, quindi chiama il suo collegamento per gli elementi dell'input. Qui, gli elementi sono le righe.

L'atomo di addizione +vettorializza, quindi l'aggiunta di due vettori di riga esegue l'aggiunta elemento per elemento. Quando gli argomenti hanno lunghezze diverse, gli elementi dell'argomento più lungo che non hanno controparte in quello più corto rimangono inalterati.

Tutto sommato, con una matrice irregolare come argomento, Scalcola la somma per colonna, saltando le voci mancanti nelle righe più brevi.

Python 2 , 47 45 byte

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

Grazie a @vaultah per giocare a golf con 2 byte!

Provalo online!

Perl 6 , 23 byte

{roundrobin(|$_)».sum}

Mathematica, 15 byte

Total@*PadRight

Haskell, 34 byte

import Data.List
map sum.transpose

Provalo online! Uso:

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

CJam , 7 5 byte

2 byte di sconto grazie a Dennis!

{:.+}

Questo definisce un blocco anonimo che accetta un elenco di elenchi, come [[1 2 3 4] [1] [5 2 3] [6 1]], e lo sostituisce con un elenco [13 5 6 4],.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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

MATL , 3 byte

oXs

( MATL non sa che il plurale di "bue" è "buoi" ... )

L'input è una matrice di celle di vettori di righe numeriche, nello stesso formato del testo della sfida:

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

Provalo online! Oppure verifica tutti i casi di test .

     % 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

Salvato 3 byte, grazie a ETHproductions

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

Casi test

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]

Meraviglia , 11 byte

@->#sum '#0

Trasponi e mappa con la funzione somma. Uso:

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

C ++ 14, 130 byte

Come lambda generico senza nome:

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

Richiede Cdi essere come vector<vector<int>>e restituire il valore rper essere come vector<int>(dovrebbe andare bene secondo meta ).

Ungolfed e utilizzo:

#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

Provalo online qui .

Haskell, 61 41 40 byte

Grazie @Laikoni per -20 byte, @nimi per -1 byte!

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

Spiegazione: È solo una somma ricorsiva dei primi elementi dell'elenco, che si occupa anche di eliminare gli elenchi vuoti in ogni passaggio intermedio:

    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

+/@:>

Accetta input come un elenco di elenchi in scatola.

Casi test

   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 byte

+⌿↑

+⌿ somma colonna

↑ l'argomento misto (elenco di elenchi, impilato in matrice, riempimento con zeri)

ProvaAPL online!

Pyke, 4 byte

.,ms

Provalo qui!

Java 8, 124 byte

questa è un'espressione lambda per 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;}

prende la massima lunghezza dell'array dall'input, crea un nuovo array di quella dimensione e quindi scrive le somme di ogni colonna nell'array.

Ottava, 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)

Ciò accetta in input un listoggetto chiamato wnel modulo:

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

Emette la somma per colonna: [1] 3 4 3 4

Questa soluzione è piuttosto lunga per me. R ha la particolarità di riciclare quando si tenta di legare vettori di diversa lunghezza. Per esempio :

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 viene riutilizzato una volta per adattarsi, motivo per cui inizio con un elenco.

Il programma regola la lunghezza di tutti gli elementi dell'elenco come quello più lungo, lega gli elementi e calcola la somma per colonna. La regolazione della lunghezza produce quelle NAche sono ignorate da sum.

-8 byte grazie a @Jarko Dubbeldam!

PHP, 63 byte

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

chiama nel browser con i parametri GET come elenco di input.

Esempio:
script.php?a[]=1&a[]=2&a[]=3&a[]=4&b[]=1&c[]=5&c[]=2&c[]=3&d[]=6&d[]=1
(i nomi di array vengono ignorati, quindi è possibile denominarli nel modo desiderato).

Prova questa funzione per il test:

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

oppure utilizzare http_build_query($array,a)per convertire un determinato array di array in parametri GET.

Clojure, 70 byte

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

Un ciclo nidificato di base.

Japt, 5 byte

Uz mx

Provalo online!

Uè l'array di input e zsugli array ruota l'array in senso orario di 90 gradi. Perciò,

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

diventa

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

(Spaziatura aggiunta solo a scopo di visualizzazione.)

mxpoi maps per sommatoria ( x), che fornisce il risultato desiderato: [13,5,6,4].