Dada una lista no vacía de filas de números no vacías, calcule la suma sabia de columnas , que es otra lista que tiene la longitud de la fila de entrada más larga. La primera entrada de la lista de salida es la suma de todos los primeros entrantes de las filas de entrada, la segunda es la suma de todos los segundos elementos (si están disponibles), etc. Creo que el siguiente ejemplo lo explicará mejor:

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]

Casos de prueba

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

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

El átomo de suma Ses una abreviatura de +/, que realiza la reducción por adición.

El rápido se /reduce a lo largo de la dimensión exterior, por lo que llama a su enlace para los elementos de la entrada. Aquí, los elementos son las filas.

El átomo de suma se +vectoriza, por lo que la suma de dos vectores de fila realiza la suma elemento por elemento. Cuando los argumentos tienen longitudes diferentes, los elementos del argumento más largo que no tienen contraparte en el más corto no se modifican.

En general, con una matriz irregular como argumento, Scalcula la suma en columnas, omitiendo las entradas que faltan en las filas más cortas.

Python 2 , 47 45 bytes

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

¡Gracias a @vaultah por jugar 2 bytes!

Pruébalo en línea!

Perl 6 , 23 bytes

{roundrobin(|$_)».sum}

Mathematica, 15 bytes

Total@*PadRight

Haskell, 34 bytes

import Data.List
map sum.transpose

Pruébalo en línea! Uso:

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

CJam , 7 5 bytes

2 bytes de descuento gracias a Dennis!

{:.+}

Esto define un bloque anónimo que toma una lista de listas, como [[1 2 3 4] [1] [5 2 3] [6 1]], y la reemplaza por una lista [13 5 6 4],.

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

MATL , 3 bytes

oXs

( MATL no sabe que el plural de "buey" es "bueyes" ... )

La entrada es una matriz de celdas de vectores de fila numéricos, en el mismo formato que en el texto de desafío:

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

Pruébalo en línea! O verificar todos los casos de prueba .

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

Guardado 3 bytes, gracias a ETHproductions

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

Casos de prueba

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]

Maravilla , 11 bytes

@->#sum '#0

Transponer y mapear con función de suma. Uso:

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

C ++ 14, 130 bytes

Como lambda genérico sin nombre:

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

Requiere Cser como vector<vector<int>>y devolver el valor rpara ser como vector<int>(debería estar bien según el meta ).

Sin golf y uso:

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

sM.T

Pruébelo en línea aquí .

Haskell, 61 41 40 bytes

¡Gracias @Laikoni por -20 bytes, @nimi por -1 byte!

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

Explicación: Es solo una suma recursiva de los primeros elementos de la lista, que también se ocupa de descartar listas vacías en cada paso 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 bytes

+/@:>

Toma la entrada como una lista en caja de listas.

Casos de prueba

   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 bytes

+⌿↑

+⌿ suma de columnas

↑ El argumento mixto (lista de lista, apilado en matriz, relleno con ceros)

TryAPL en línea!

Pyke, 4 bytes

.,ms

Pruébalo aquí!

Java 8, 124 bytes

esta es una expresión lambda para 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;}

toma la mayor longitud de matriz de la entrada, crea una nueva matriz de ese tamaño y luego escribe las sumas de cada columna en la matriz.

Octava, 69 bytes

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

R, 105 97 bytes

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)

Esto toma como entrada un listobjeto llamado wen la forma:

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

Produce la suma de columnas: [1] 3 4 3 4

Esta solución es bastante larga para mí. R tiene la particularidad de reciclar cuando intentas unir vectores de diferente longitud. Por ejemplo :

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 se reutiliza una vez para encajar, por eso empiezo con una lista.

El programa ajusta la longitud de todos los elementos de la lista como uno de los más largos, une los elementos y calcula la suma en columnas. El ajuste de longitud produce NA's, que son ignorados por el sum.

-8 bytes gracias a @Jarko Dubbeldam!

PHP, 63 bytes

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

Llame al navegador con parámetros GET como lista de entradas.

Ejemplo:
script.php?a[]=1&a[]=2&a[]=3&a[]=4&b[]=1&c[]=5&c[]=2&c[]=3&d[]=6&d[]=1
(los nombres de matriz se ignoran, por lo que puede nombrarlos de la forma que desee).

Pruebe esta función para probar:

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

o úselo http_build_query($array,a)para convertir una determinada matriz de matrices en parámetros GET.

Clojure, 70 bytes

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

Un bucle anidado básico.

Japt, 5 bytes

Uz mx

¡Pruébelo en línea!

Ues la matriz de entrada, y zen las matrices gira la matriz en sentido horario 90 grados. Por lo tanto,

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

se convierte

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

(Se agrega espacio solo para fines de visualización).

mxa continuación, maps mediante la suma ( x), que da el resultado deseado: [13,5,6,4].