Commande shell pour additionner des entiers, un par ligne?

Je recherche une commande qui acceptera (en entrée) plusieurs lignes de texte, chaque ligne contenant un seul entier, et produira la somme de ces entiers.

En guise de contexte, j'ai un fichier journal qui comprend des mesures de synchronisation. Grâce à la recherche des lignes pertinentes et un peu de sedreformatage, je peux répertorier tous les timings dans ce fichier. Je voudrais calculer le total. Je peux diriger cette sortie intermédiaire vers n'importe quelle commande afin de faire la somme finale. Je l'ai toujours utilisé exprdans le passé, mais à moins qu'il ne fonctionne en mode RPN, je ne pense pas qu'il va y faire face (et même alors, ce serait délicat).

Comment obtenir la somme des nombres entiers?

Un peu d'awk devrait le faire?

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

Remarque: certaines versions de awk ont ​​des comportements étranges si vous souhaitez ajouter quelque chose dépassant 2 ^ 31 (2147483647). Voir les commentaires pour plus d'informations. Une suggestion est d'utiliser printfplutôt que print:

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

Coller fusionne généralement les lignes de plusieurs fichiers, mais il peut également être utilisé pour convertir des lignes individuelles d'un fichier en une seule ligne. L'indicateur de délimitation vous permet de passer une équation de type x + x à bc.

paste -s -d+ infile | bc

Alternativement, lorsque vous canalisez depuis stdin,

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

La version monoligne en Python:

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

Je mettrais un gros AVERTISSEMENT sur la solution couramment approuvée:

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

c'est parce que dans ce formulaire, awk utilise une représentation d'entier signé 32 bits: il débordera pour les sommes qui dépassent 2147483647 (c'est-à-dire 2 ^ 31).

Une réponse plus générale (pour additionner des entiers) serait:

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

Bash simple:

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

Notez que les nombres négatifs préfixés par le signe moins doivent être traduits pour dc, car il utilise le _préfixe plutôt que le -préfixe pour cela. Par exemple, via tr '-' '_' | dc -f- -e '...'.

Edit: Puisque cette réponse a obtenu autant de votes "pour l'obscurité", voici une explication détaillée:

L'expression [+z1<r]srz1<rp fait ce qui suit :

[   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

Comme pseudo-code:

1. Définissez "add_top_of_stack" comme:
   1. Retirez les deux premières valeurs de la pile et ajoutez le résultat
   2. Si la pile a deux ou plusieurs valeurs, exécutez récursivement "add_top_of_stack"
2. Si la pile a deux ou plusieurs valeurs, exécutez "add_top_of_stack"
3. Imprimer le résultat, désormais le seul élément restant dans la pile

Pour vraiment comprendre la simplicité et la puissance de dc, voici un script Python fonctionnel qui implémente certaines des commandes de dcet exécute une version Python de la commande ci-dessus:

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

Avec jq :

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

Bash pur et court.

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

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

Mes quinze cents:

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

Exemple:

$ 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

J'ai fait une référence rapide sur les réponses existantes qui

• utilisez uniquement des outils standard (désolé pour des trucs comme luaou rocket),
• sont de vrais one-liners,
• sont capables d'ajouter d'énormes quantités de chiffres (100 millions), et
• sont rapides (j'ai ignoré ceux qui ont pris plus d'une minute).

J'ai toujours ajouté les nombres de 1 à 100 millions qui étaient réalisables sur ma machine en moins d'une minute pour plusieurs solutions.

Voici les résultats:

Python

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

Coller & Bc

Cela a manqué de mémoire sur ma machine. Cela a fonctionné pour la moitié de la taille de l'entrée (50 millions de numéros):

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

Je suppose donc qu'il aurait fallu environ 35 secondes pour les 100 millions de numéros.

Perl

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

Rubis

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

C

À titre de comparaison, j'ai compilé la version C et je l'ai également testée, juste pour avoir une idée de la lenteur des solutions basées sur les outils.

#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

Conclusion

C est bien sûr le plus rapide avec 8 s, mais la solution Pypy n'ajoute qu'un très petit surcoût d'environ 30% à 11 s . Mais, pour être juste, Pypy n'est pas exactement standard. La plupart des gens n'ont installé que CPython, ce qui est beaucoup plus lent (22 s), exactement aussi vite que la solution Awk populaire.

La solution la plus rapide basée sur des outils standard est Perl (15s).

Doublure simple bash one

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

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

Solution BASH, si vous voulez en faire une commande (par exemple si vous devez le faire fréquemment):

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

Puis utilisation:

addnums < /tmp/nums

Je pense que AWK est ce que vous recherchez:

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

Vous pouvez utiliser cette commande soit en passant la liste des nombres via l'entrée standard, soit en passant le fichier contenant les nombres en tant que paramètre.

Les travaux suivants dans bash:

I=0

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

echo $I

Vous pouvez utiliser num-utils, même si cela peut être exagéré pour ce dont vous avez besoin. Il s'agit d'un ensemble de programmes pour manipuler les nombres dans le shell, et peut faire plusieurs choses astucieuses, y compris bien sûr, les additionner. C'est un peu dépassé, mais ils fonctionnent toujours et peuvent être utiles si vous avez besoin de faire quelque chose de plus.

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

Je me rends compte que c'est une vieille question, mais j'aime assez cette solution pour la partager.

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

S'il y a un intérêt, je vais vous expliquer comment cela fonctionne.

Pure bash et dans une doublure :-)

$ 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

Alternative pure Perl, assez lisible, aucun package ni option requis:

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

Pour les amateurs de rubis

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

Impossible d'éviter de soumettre ceci:

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

On le trouve ici: Le
plus élégant one-liner shell unix pour résumer la liste des nombres de précision arbitraire?

Et voici ses avantages spéciaux par rapport à awk, bc et ses amis:

• cela ne dépend pas de la mise en mémoire tampon et ne s'étouffe donc pas avec de très grandes entrées
• cela n'implique aucune précision particulière - ou taille entière pour cette matière - limite
• pas besoin de code différent, si des nombres à virgule flottante doivent être ajoutés

Utilisation de l' utilitaire GNU datamash :

seq 10 | datamash sum 1

Production:

55

Si les données d'entrée sont irrégulières, avec des espaces et des tabulations à des endroits impairs, cela peut être source de confusion datamash, alors utilisez le -Wcommutateur:

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

... ou utilisez trpour nettoyer l'espace blanc:

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

Ma version:

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

Vous pouvez le faire en python, si vous vous sentez à l'aise:

Non testé, juste tapé:

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

Sebastian a souligné un script à une ligne:

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, vous pouvez taper les chiffres sur la ligne de commande:

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

Cependant, celui-ci ralentit le fichier, il n'est donc pas judicieux de l'utiliser sur des fichiers volumineux. Voir la réponse de j_random_hacker qui évite le slurping.

Les éléments suivants devraient fonctionner (en supposant que votre numéro est le deuxième champ de chaque ligne).

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

Une doublure en raquette:

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

C (non simplifié)

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)

Toutes mes excuses à l'avance pour la lisibilité des backticks (""), mais ceux-ci fonctionnent dans des shells autres que bash et sont donc plus collables. Si vous utilisez un shell qui l'accepte, le format $ (command ...) est beaucoup plus lisible (et donc déboguable) que `command ...` alors n'hésitez pas à le modifier pour votre raison.

J'ai une fonction simple dans mon bashrc qui utilisera awk pour calculer un certain nombre d'éléments mathématiques simples

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

Cela fera +, -, *, /, ^,%, sqrt, sin, cos, parenthesis .... (et plus en fonction de votre version de awk) ... vous pourriez même avoir de l'imagination avec printf et le format à virgule flottante sortie, mais c'est tout ce dont j'ai normalement besoin

pour cette question particulière, je ferais simplement ceci pour chaque ligne:

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

donc le bloc de code pour additionner chaque ligne ressemblerait à ceci:

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

C'est si vous vouliez seulement les additionner ligne par ligne. Cependant, pour un total de chaque nombre dans le fichier de données

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

btw si j'ai besoin de faire quelque chose de rapide sur le bureau, j'utilise ceci:

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