Étant donné une liste non vide de lignes de nombres non vides, calculez la somme par colonne , qui est une autre liste qui a la longueur de la ligne d'entrée la plus longue. La première entrée de la liste de sortie est la somme de toutes les premières entrées des lignes d'entrée, la seconde est la somme de tous les seconds éléments (si disponibles) etc. Je pense que l'exemple suivant l'expliquera mieux:

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]

Cas de 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]

Gelée , 1 octet

S

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

L'atome somme Sest un raccourci pour +/, qui effectue la réduction par addition.

Le rapide se /réduit le long de la dimension la plus à l'extérieur, il appelle donc son lien pour les éléments de l'entrée. Ici, les éléments sont les lignes.

L'atome d'addition +vectorise, donc l'ajout de deux vecteurs de ligne effectue l'addition élément par élément. Lorsque les arguments ont des longueurs différentes, les éléments de l'argument le plus long qui n'ont pas d'équivalent dans le plus court ne sont pas modifiés.

Dans l'ensemble, avec une matrice irrégulière comme argument, Scalcule la somme par colonne, en sautant les entrées manquantes dans les lignes les plus courtes.

Python 2 , 47 45 octets

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

Merci à @vaultah d'avoir joué au golf sur 2 octets!

Essayez-le en ligne!

Perl 6 , 23 octets

{roundrobin(|$_)».sum}

Mathematica, 15 octets

Total@*PadRight

Haskell, 34 octets

import Data.List
map sum.transpose

Essayez-le en ligne! Usage:

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

CJam , 7 5 octets

2 octets de réduction grâce à Dennis!

{:.+}

Ceci définit un bloc anonyme qui prend une liste de listes, telles que [[1 2 3 4] [1] [5 2 3] [6 1]], et la remplace par une liste [13 5 6 4],.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

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

MATL , 3 octets

oXs

( MATL ne sait pas que le pluriel de "bœuf" est "bœufs" ... )

L'entrée est un tableau de cellules de vecteurs de lignes numériques, au même format que dans le texte du défi:

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

Essayez-le en ligne! Ou vérifiez tous les cas de 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 octets

Enregistré 3 octets, grâce à ETHproductions

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

Cas de 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]

Wonder , 11 octets

@->#sum '#0

Transposer et cartographier avec la fonction somme. Usage:

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

C ++ 14, 130 octets

En tant que lambda générique sans nom:

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

Nécessite Cd'être similaire vector<vector<int>>et de renvoyer la valeur rpour être similaire vector<int>(devrait être correct selon la méta ).

Non golfé et utilisation:

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

sM.T

Essayez-le en ligne ici .

Haskell, 61 41 40 octets

Merci @Laikoni pour -20 octets, @nimi pour -1 octet!

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

Explication: il s'agit simplement d'un résumé récursif des premiers éléments de la liste, traitant également de l'élimination des listes vides à chaque étape intermédiaire:

    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 octets

+/@:>

Prend la saisie sous forme de liste encadrée de listes.

Cas de 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 octets

+⌿↑

+⌿ somme par colonne

↑ l'argument mixte (liste de liste, empilé dans la matrice, remplissage avec des zéros)

TryAPL en ligne!

Pyke, 4 octets

.,ms

Essayez-le ici!

Java 8, 124 octets

c'est une expression lambda pour un 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;}

il prend la plus grande longueur de tableau de l'entrée, crée un nouveau tableau de cette taille, puis écrit les sommes de chaque colonne dans le tableau.

Octave, 69 octets

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

R, 105 97 octets

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)

Cela prend en entrée un listobjet appelé wsous la forme:

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

Il génère la somme par colonne: [1] 3 4 3 4

Cette solution est assez longue pour moi. R a la particularité de recycler lorsque vous essayez de lier des vecteurs de longueur différente. Par exemple :

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 est réutilisé une fois pour s'adapter, c'est pourquoi je commence par une liste.

Le programme ajuste la longueur de tous les éléments de la liste comme l'un des plus longs, lie les éléments et calcule la somme par colonne. Le réglage de la longueur produit NAdes, qui sont ignorés par le sum.

-8 octets grâce à @Jarko Dubbeldam!

PHP, 63 octets

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

appeler dans le navigateur avec les paramètres GET comme liste d'entrées.

Exemple:
script.php?a[]=1&a[]=2&a[]=3&a[]=4&b[]=1&c[]=5&c[]=2&c[]=3&d[]=6&d[]=1
(Les noms de tableaux sont ignorés, vous pouvez donc les nommer comme vous le souhaitez.)

Essayez cette fonction pour tester:

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

ou utilisez http_build_query($array,a)pour convertir un tableau donné de tableaux en paramètres GET.

Clojure, 70 octets

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

Une boucle imbriquée de base.

Japt, 5 octets

Uz mx

Testez-le en ligne!

Uest le tableau d'entrée, et zsur les tableaux fait pivoter le tableau dans le sens horaire de 90 degrés. Par conséquent,

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

devient

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

(Espacement ajouté uniquement à des fins d'affichage.)

mxpuis maps par sommation ( x), ce qui donne le résultat souhaité: [13,5,6,4].