Comando Shell para somar números inteiros, um por linha?

Estou procurando um comando que aceite (como entrada) várias linhas de texto, cada linha contendo um único inteiro e produza a soma desses números inteiros.

Como pano de fundo, tenho um arquivo de log que inclui medições de tempo. Através do grepping para as linhas relevantes e um pouco de sedreformatação, posso listar todas as temporizações nesse arquivo. Eu gostaria de calcular o total. Eu posso canalizar essa saída intermediária para qualquer comando para fazer a soma final. Eu sempre usei exprno passado, mas, a menos que seja executado no modo RPN, não acho que vai lidar com isso (e mesmo assim seria complicado).

Como posso obter a soma dos números inteiros?

Um pouco de awk deve fazer isso?

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

Nota: algumas versões do awk têm comportamentos estranhos se você adicionar algo que exceda 2 ^ 31 (2147483647). Veja os comentários para mais informações. Uma sugestão é usar em printfvez de print:

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

Colar normalmente mescla linhas de vários arquivos, mas também pode ser usado para converter linhas individuais de um arquivo em uma única linha. O sinalizador delimitador permite passar uma equação do tipo x + x para bc.

paste -s -d+ infile | bc

Como alternativa, ao canalizar a partir de stdin,

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

A versão one-liner no Python:

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

Eu colocaria um grande aviso sobre a solução comumente aprovada:

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

isso ocorre porque, neste formulário, o awk usa uma representação inteira assinada de 32 bits: ele excederá as somas que excedem 2147483647 (ou seja, 2 ^ 31).

Uma resposta mais geral (para somar números inteiros) seria:

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

Festa simples:

$ 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'

Observe que números negativos prefixados com sinal de menos devem ser traduzidos dc, pois ele usa _prefixo em vez de -prefixo para isso. Por exemplo, via tr '-' '_' | dc -f- -e '...'.

Edit: Como esta resposta obteve tantos votos "pela obscuridade", aqui está uma explicação detalhada:

A expressão [+z1<r]srz1<rp faz o seguinte :

[   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 pseudo-código:

1. Defina "add_top_of_stack" como:
   1. Remova os dois principais valores da pilha e adicione o resultado novamente
   2. Se a pilha tiver dois ou mais valores, execute "add_top_of_stack" recursivamente
2. Se a pilha tiver dois ou mais valores, execute "add_top_of_stack"
3. Imprima o resultado, agora o único item restante na pilha

Para realmente entender a simplicidade e o poder de dc, aqui está um script Python funcional que implementa alguns dos comandos dce executa uma versão Python do comando acima:

### 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()

Com jq :

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

Festança pura e curta.

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

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

Meus quinze centavos:

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

Exemplo:

$ 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

Fiz uma referência rápida nas respostas existentes que

• use apenas ferramentas padrão (desculpe por coisas como luaou rocket),
• são one-liners reais,
• são capazes de adicionar grandes quantidades de números (100 milhões) e
• são rápidos (eu ignorei os que levaram mais de um minuto).

Sempre adicionei os números de 1 a 100 milhões que eram factíveis na minha máquina em menos de um minuto para várias soluções.

Aqui estão os resultados:

Pitão

:; 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

Colar & Bc

Isso ficou sem memória na minha máquina. Funcionou para metade do tamanho da entrada (50 milhões de números):

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

Então eu acho que levaria aproximadamente 35s para os 100 milhões 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

Rubi

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

C

Apenas para fins de comparação, compilei a versão C e testei isso também, apenas para ter uma idéia de quanto as soluções baseadas em ferramentas são mais lentas.

#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

Conclusão

É claro que C é mais rápido com 8s, mas a solução Pypy adiciona apenas uma sobrecarga muito pequena de cerca de 30% a 11s . Mas, para ser justo, o Pypy não é exatamente padrão. A maioria das pessoas tem apenas o CPython instalado, o que é significativamente mais lento (22s), exatamente tão rápido quanto a solução Awk popular.

A solução mais rápida baseada em ferramentas padrão é o Perl (15s).

Forro liso da festança um

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

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

Solução BASH, se você quiser fazer deste um comando (por exemplo, se você precisar fazer isso com frequência):

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

Então uso:

addnums < /tmp/nums

Eu acho que AWK é o que você está procurando:

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

Você pode usar este comando passando a lista de números pela entrada padrão ou passando o arquivo que contém os números como parâmetro.

O seguinte funciona no bash:

I=0

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

echo $I

Você pode usar num-utils, embora possa ser um exagero para o que você precisa. Este é um conjunto de programas para manipular números no shell e pode fazer várias coisas bacanas, incluindo, é claro, adicioná-las. Está um pouco desatualizado, mas eles ainda funcionam e podem ser úteis se você precisar fazer algo mais.

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

Sei que essa é uma pergunta antiga, mas gosto dessa solução o suficiente para compartilhá-la.

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

Se houver interesse, explicarei como funciona.

Pure bash e em uma linha :-)

$ 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, razoavelmente legível, sem pacotes ou opções necessárias:

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

Para os amantes de Ruby

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

Não é possível evitar o envio deste:

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

Pode ser encontrado aqui:
O linux de uma linha mais elegante do shell unix para somar uma lista de números de precisão arbitrária?

E aqui estão suas vantagens especiais sobre o awk, bc e amigos:

• não depende de buffer e, portanto, não engasga com entradas realmente grandes
• não implica precisão específica - ou tamanho inteiro para esse assunto - limites
• não é necessário código diferente, se for necessário adicionar números de ponto flutuante

Usando o utilitário GNU datamash :

seq 10 | datamash sum 1

Resultado:

55

Se os dados de entrada forem irregulares, com espaços e tabulações em locais ímpares, isso pode confundir datamash, então use o -Wcomutador:

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

... ou use trpara limpar o espaço em branco:

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

Minha versão:

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

Você pode fazer isso em python, se sentir-se confortável:

Não testado, apenas digitado:

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

Sebastian apontou um roteiro único:

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

$ cat n
2
4
2
7
8
9

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

Ou, você pode digitar os números na linha de comando:

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

No entanto, este comporta o arquivo, portanto, não é uma boa ideia usá-lo em arquivos grandes. Veja a resposta de j_random_hacker, que evita o slurping.

O seguinte deve funcionar (supondo que seu número seja o segundo campo em cada linha).

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

Uma linha na raquete:

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

C (não 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)

Pedimos desculpas antecipadamente pela legibilidade dos backticks ("` "), mas eles funcionam em conchas que não sejam o bash e, portanto, são mais fáceis de colar. Se você usa um shell que o aceita, o formato $ (command ...) é muito mais legível (e, portanto, depurável) do que o `command ...` então sinta-se à vontade para modificar sua sanidade.

Eu tenho uma função simples no meu bashrc que usará o awk para calcular vários itens simples de matemática

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

Isso fará +, -, *, /, ^,%, sqrt, sin, cos, parênteses .... (e mais, dependendo da sua versão do awk) ... você pode até gostar do ponto flutuante printf e format saída, mas isso é tudo que eu normalmente preciso

para esta pergunta em particular, eu simplesmente faria isso para cada linha:

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

então o bloco de código para somar cada linha ficaria assim:

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

Isto é, se você quiser somar apenas linha por linha. No entanto, para um total de cada número no arquivo de dados

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

btw se eu precisar fazer algo rápido na área de trabalho, eu uso o seguinte:

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