¿Comando Shell para sumar enteros, uno por línea?

Estoy buscando un comando que acepte (como entrada) varias líneas de texto, cada línea que contenga un solo entero, y genere la suma de estos enteros.

Como fondo, tengo un archivo de registro que incluye mediciones de tiempo. A través del grepping para las líneas relevantes y un poco de sedformateo, puedo enumerar todos los tiempos en ese archivo. Me gustaría calcular el total. Puedo canalizar esta salida intermedia a cualquier comando para hacer la suma final. Siempre lo he usado expren el pasado, pero a menos que se ejecute en modo RPN, no creo que vaya a hacer frente a esto (e incluso entonces sería complicado).

¿Cómo puedo obtener la suma de enteros?

¿Un poco de awk debería hacerlo?

awk '{s+=$1} END {print s}' mydatafile

Nota: algunas versiones de awk tienen comportamientos extraños si va a agregar algo que exceda 2 ^ 31 (2147483647). Ver comentarios para más antecedentes. Una sugerencia es usar en printflugar de print:

awk '{s+=$1} END {printf "%.0f", s}' mydatafile

Pegar normalmente combina líneas de varios archivos, pero también se puede usar para convertir líneas individuales de un archivo en una sola línea. El indicador delimitador le permite pasar una ecuación de tipo x + x a bc.

paste -s -d+ infile | bc

Alternativamente, al conectar desde stdin,

<commands> | paste -s -d+ - | bc

La versión de una línea en Python:

$ python -c "import sys; print(sum(int(l) for l in sys.stdin))"

Pondría una gran ADVERTENCIA en la solución comúnmente aprobada:

awk '{s+=$1} END {print s}' mydatafile # DO NOT USE THIS!!

eso es porque en esta forma awk usa una representación entera con signo de 32 bits: se desbordará para sumas que excedan 2147483647 (es decir, 2 ^ 31).

Una respuesta más general (para sumar enteros) sería:

awk '{s+=$1} END {printf "%.0f\n", s}' mydatafile # USE THIS INSTEAD

Golpe llano:

$ cat numbers.txt 
1
2
3
4
5
6
7
8
9
10
$ sum=0; while read num; do ((sum += num)); done < numbers.txt; echo $sum
55

dc -f infile -e '[+z1<r]srz1<rp'

Tenga en cuenta que los números negativos con el prefijo menos deben traducirse dc, ya que utiliza _prefijo en lugar de -prefijo para eso. Por ejemplo, vía tr '-' '_' | dc -f- -e '...'.

Editar: Dado que esta respuesta obtuvo tantos votos "por oscuridad", aquí hay una explicación detallada:

La expresión [+z1<r]srz1<rp hace lo siguiente :

[   interpret everything to the next ] as a string
  +   push two values off the stack, add them and push the result
  z   push the current stack depth
  1   push one
  <r  pop two values and execute register r if the original top-of-stack (1)
      is smaller
]   end of the string, will push the whole thing to the stack
sr  pop a value (the string above) and store it in register r
z   push the current stack depth again
1   push 1
<r  pop two values and execute register r if the original top-of-stack (1)
    is smaller
p   print the current top-of-stack

Como seudocódigo:

1. Defina "add_top_of_stack" como:
   1. Elimine los dos valores superiores de la pila y agregue el resultado nuevamente
   2. Si la pila tiene dos o más valores, ejecute "add_top_of_stack" de forma recursiva
2. Si la pila tiene dos o más valores, ejecute "add_top_of_stack"
3. Imprima el resultado, ahora el único elemento que queda en la pila

Para comprender realmente la simplicidad y el poder de dc, aquí hay un script de Python en funcionamiento que implementa algunos de los comandos dcy ejecuta una versión de Python del comando anterior:

### Implement some commands from dc
registers = {'r': None}
stack = []
def add():
    stack.append(stack.pop() + stack.pop())
def z():
    stack.append(len(stack))
def less(reg):
    if stack.pop() < stack.pop():
        registers[reg]()
def store(reg):
    registers[reg] = stack.pop()
def p():
    print stack[-1]

### Python version of the dc command above

# The equivalent to -f: read a file and push every line to the stack
import fileinput
for line in fileinput.input():
    stack.append(int(line.strip()))

def cmd():
    add()
    z()
    stack.append(1)
    less('r')

stack.append(cmd)
store('r')
z()
stack.append(1)
less('r')
p()

Con jq :

seq 10 | jq -s 'add' # 'add' is equivalent to 'reduce .[] as $item (0; . + $item)'

Golpe puro y corto.

f=$(cat numbers.txt)
echo $(( ${f//$'\n'/+} ))

perl -lne '$x += $_; END { print $x; }' < infile.txt

Mis quince centavos:

$ cat file.txt | xargs  | sed -e 's/\ /+/g' | bc

Ejemplo:

$ cat text
1
2
3
3
4
5
6
78
9
0
1
2
3
4
576
7
4444
$ cat text | xargs  | sed -e 's/\ /+/g' | bc 
5148

He hecho un punto de referencia rápido sobre las respuestas existentes que

• use solo herramientas estándar (perdón por cosas como luao rocket),
• son frases reales,
• son capaces de agregar grandes cantidades de números (100 millones), y
• son rápidos (ignoré los que tomaron más de un minuto).

Siempre agregué los números de 1 a 100 millones que era factible en mi máquina en menos de un minuto para varias soluciones.

Aquí están los resultados:

Pitón

:; seq 100000000 | python -c 'import sys; print sum(map(int, sys.stdin))'
5000000050000000
# 30s
:; seq 100000000 | python -c 'import sys; print sum(int(s) for s in sys.stdin)'
5000000050000000
# 38s
:; seq 100000000 | python3 -c 'import sys; print(sum(int(s) for s in sys.stdin))'
5000000050000000
# 27s
:; seq 100000000 | python3 -c 'import sys; print(sum(map(int, sys.stdin)))'
5000000050000000
# 22s
:; seq 100000000 | pypy -c 'import sys; print(sum(map(int, sys.stdin)))'
5000000050000000
# 11s
:; seq 100000000 | pypy -c 'import sys; print(sum(int(s) for s in sys.stdin))'
5000000050000000
# 11s

Awk

:; seq 100000000 | awk '{s+=$1} END {print s}'
5000000050000000
# 22s

Pasta y Bc

Esto se quedó sin memoria en mi máquina. Funcionó por la mitad del tamaño de la entrada (50 millones de números):

:; seq 50000000 | paste -s -d+ - | bc
1250000025000000
# 17s
:; seq 50000001 100000000 | paste -s -d+ - | bc
3750000025000000
# 18s

Entonces supongo que habría tomado ~ 35s para los 100 millones de números.

Perl

:; seq 100000000 | perl -lne '$x += $_; END { print $x; }'
5000000050000000
# 15s
:; seq 100000000 | perl -e 'map {$x += $_} <> and print $x'
5000000050000000
# 48s

Rubí

:; seq 100000000 | ruby -e "puts ARGF.map(&:to_i).inject(&:+)"
5000000050000000
# 30s

C

Solo por el bien de la comparación, compilé la versión C y probé esto también, solo para tener una idea de cuánto más lentas son las soluciones basadas en herramientas.

#include <stdio.h>
int main(int argc, char** argv) {
    long sum = 0;
    long i = 0;
    while(scanf("%ld", &i) == 1) {
        sum = sum + i;
    }
    printf("%ld\n", sum);
    return 0;
}

:; seq 100000000 | ./a.out 
5000000050000000
# 8s

Conclusión

C es, por supuesto, el más rápido con 8s, pero la solución Pypy solo agrega una sobrecarga muy pequeña de aproximadamente 30% a 11s . Pero, para ser justos, Pypy no es exactamente estándar. La mayoría de las personas solo tienen instalado CPython, que es significativamente más lento (22 s), exactamente tan rápido como la popular solución Awk.

La solución más rápida basada en herramientas estándar es Perl (15s).

Plain bash one liner

$ cat > /tmp/test
1 
2 
3 
4 
5
^D

$ echo $(( $(cat /tmp/test | tr "\n" "+" ) 0 ))

Solución BASH, si desea hacer esto un comando (por ejemplo, si necesita hacer esto con frecuencia):

addnums () {
  local total=0
  while read val; do
    (( total += val ))
  done
  echo $total
}

Entonces uso:

addnums < /tmp/nums

Creo que AWK es lo que estás buscando:

awk '{sum+=$1}END{print sum}'

Puede usar este comando ya sea pasando la lista de números a través de la entrada estándar o pasando el archivo que contiene los números como parámetro.

Lo siguiente funciona en bash:

I=0

for N in `cat numbers.txt`
do
    I=`expr $I + $N`
done

echo $I

Puede usar num-utils, aunque puede ser excesivo para lo que necesita. Este es un conjunto de programas para manipular números en el shell, y puede hacer varias cosas ingeniosas, incluso, por supuesto, sumarlas. Está un poco desactualizado, pero aún funcionan y pueden ser útiles si necesita hacer algo más.

http://suso.suso.org/programs/num-utils/

Me doy cuenta de que esta es una vieja pregunta, pero me gusta esta solución lo suficiente como para compartirla.

% cat > numbers.txt
1 
2 
3 
4 
5
^D
% cat numbers.txt | perl -lpe '$c+=$_}{$_=$c'
15

Si hay interés, explicaré cómo funciona.

Golpe puro y de una sola línea :-)

$ cat numbers.txt
1
2
3
4
5
6
7
8
9
10


$ I=0; for N in $(cat numbers.txt); do I=$(($I + $N)); done; echo $I
55

sed 's/^/.+/' infile | bc | tail -1

Perl puro alternativo, bastante legible, no se requieren paquetes u opciones:

perl -e "map {$x += $_} <> and print $x" < infile.txt

Para los amantes del rubí

ruby -e "puts ARGF.map(&:to_i).inject(&:+)" numbers.txt

No puedo evitar enviar esto:

jot 1000000 | sed '2,$s/$/+/;$s/$/p/' | dc

Se encuentra aquí: ¿
La línea elegante de caparazón Unix más elegante para sumar la lista de números de precisión arbitraria?

Y aquí están sus ventajas especiales sobre awk, bc y amigos:

• no depende del almacenamiento en búfer y, por lo tanto, no se ahoga con entradas realmente grandes
• no implica una precisión particular -o tamaño entero para esa materia- límites
• no es necesario un código diferente, si es necesario agregar números de coma flotante

Usando la utilidad GNU datamash :

seq 10 | datamash sum 1

Salida:

55

Si los datos de entrada son irregulares, con espacios y pestañas en lugares impares, esto puede confundir datamash, entonces use el -Winterruptor:

<commands...> | datamash -W sum 1

... o use trpara limpiar el espacio en blanco:

<commands...> | tr -d '[[:blank:]]' | datamash sum 1

Mi version:

seq -5 10 | xargs printf "- - %s" | xargs  | bc

Puedes hacerlo en python, si te sientes cómodo:

No probado, solo escrito:

out = open("filename").read();
lines = out.split('\n')
ints = map(int, lines)
s = sum(ints)
print s

Sebastian señaló un guión de una línea:

cat filename | python -c"from fileinput import input; print sum(map(int, input()))"

$ cat n
2
4 4
2
7 7
8
9 9

$ perl -MList::Util -le 'print List::Util::sum(<>)' < n
32

O bien, puede escribir los números en la línea de comando:

$ perl -MList::Util -le 'print List::Util::sum(<>)'
1
3
5
^D
9

Sin embargo, este extrae el archivo, por lo que no es una buena idea usarlo en archivos grandes. Vea la respuesta de j_random_hacker que evita sorber.

Lo siguiente debería funcionar (suponiendo que su número sea el segundo campo en cada línea).

awk 'BEGIN {sum=0} \
 {sum=sum + $2} \
END {print "tot:", sum}' Yourinputfile.txt

One-liner en raqueta:

racket -e '(define (g) (define i (read)) (if (eof-object? i) empty (cons i (g)))) (foldr + 0 (g))' < numlist.txt

C (no simplificado)

seq 1 10 | tcc -run <(cat << EOF
#include <stdio.h>
int main(int argc, char** argv) {
    int sum = 0;
    int i = 0;
    while(scanf("%d", &i) == 1) {
        sum = sum + i;
    }
    printf("%d\n", sum);
    return 0;
}
EOF)

Disculpas de antemano por la legibilidad de los backticks ("` "), pero estos funcionan en shells que no sean bash y, por lo tanto, son más pegajosos. Si usa un shell que lo acepta, el formato $ (comando ...) es mucho más legible (y, por lo tanto, depurable) que 'comando ...', así que siéntase libre de modificarlo por su cordura.

Tengo una función simple en mi bashrc que usará awk para calcular una cantidad de elementos matemáticos simples

calc(){
  awk 'BEGIN{print '"$@"' }'
}

Esto hará +, -, *, /, ^,%, sqrt, sin, cos, paréntesis ... (y más, dependiendo de su versión de awk) ... incluso podría imaginarse con printf y formatear el punto flotante salida, pero esto es todo lo que normalmente necesito

para esta pregunta en particular, simplemente haría esto para cada línea:

calc `echo "$@"|tr " " "+"`

entonces el bloque de código para sumar cada línea se vería así:

while read LINE || [ "$LINE" ]; do
  calc `echo "$LINE"|tr " " "+"` #you may want to filter out some lines with a case statement here
done

Eso si quisieras sumar solo línea por línea. Sin embargo, para un total de cada número en el archivo de datos

VARS=`<datafile`
calc `echo ${VARS// /+}`

por cierto, si necesito hacer algo rápido en el escritorio, uso esto:

xcalc() { 
  A=`calc "$@"`
  A=`Xdialog --stdout --inputbox "Simple calculator" 0 0 $A`
  [ $A ] && xcalc $A
}