Suma sabia de columna

30

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]
falla
fuente
¿Las matrices solo contendrán enteros?
ETHproductions
No pensé en eso hasta ahora, pero creo que puedes asumir eso. ¿Hay algo que hable en contra de eso?
defecto
No lo creo. Todos sus casos de prueba usan solo enteros, y estoy bastante seguro de que no invalidará ninguna respuesta existente (e incluso puede guardar bytes para algunas respuestas).
ETHproductions
Bueno, entonces creo que esta suposición es perfectamente aceptable. Tampoco cambia el desafío en sí.
defecto

Respuestas:

19

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.

Dennis
fuente
1
Huh, hubiera esperado que fuera una suma de filas, dada la forma en que la autovectorización normalmente funciona en Jelly. Supongo que la suma en filas sería S€, entonces.
1
Para una matriz 2D, sí. /no se vectoriza; simplemente aplica la diada correspondiente a todos los elementos de su argumento.
Dennis
9

Mathematica, 15 bytes

Total@*PadRight
alephalpha
fuente
8

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]
Laikoni
fuente
Es bueno conocer las bibliotecas, siempre tengo miedo de importque ya
consume
8

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
Luis Mendo
fuente
7

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
Luis Mendo
fuente
Muy inteligente utilizar células =)
flawr
4

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

Arnauld
fuente
¿Qué estaba mal con reduce? a=>a.reduce((l,r)=>r.map((e,i)=>e+(l[i]||0)))solo tiene 45 bytes.
Neil
@Neil ¿No limitaría eso el tamaño del resultado final al tamaño de la última matriz procesada?
Arnauld
Ah, los casos de prueba no pudieron detectar mi error, ¡gracias!
Neil
3

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]]
Mama Fun Roll
fuente
3

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;
}
Karl Napf
fuente
3

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
falla
fuente
El uso de comprensiones de listas ahorra bastantes bytes: puede reemplazar (sum$sum.(take 1)<$>l)con sum[h|h:_<-l]y (f$filter(/=[])$drop 1<$>l)con f[t|_:t<-l,t>[]].
Laikoni
¡Wow, muchas gracias! ¡Siempre me olvido de la posibilidad de unir patrones [h|h:_<-l]!
defecto
Un byte se puede guardar en la llamada recursiva: f[t:u|_:t:u<-l].
nimi
2

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
Conor O'Brien
fuente
2

Dyalog APL , 3 bytes

+⌿↑

+⌿ suma de columnas

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

TryAPL en línea!

Adán
fuente
2
¿Cómo demonios son estos 10 bytes?
Zacharý
3
@ZacharyT Eso es lo que sucede cuando se usa una plantilla a las 12:30 a.m.
Adám
1

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.

Jack munición
fuente
1

Octava, 69 bytes

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

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!

Frédéric
fuente
colSums(a,na.rm=T)Guarda algunos bytes.
JAD
e incluso se puede convertir na.rm=Ten n=T.
JAD
1

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.

Tito
fuente
0

Clojure, 70 bytes

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

Un bucle anidado básico.

NikoNyrh
fuente
0

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

ETHproducciones
fuente