Commande Shell pour additionner des nombres entiers, un par ligne ?

Question

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

Pour la petite histoire, j'ai un fichier journal qui contient des mesures de temps. En recherchant les lignes pertinentes et en faisant un peu de sed En reformatant le fichier, je peux énumérer toutes les durées qu'il contient. Je voudrais faire le total. Je peux acheminer cette sortie intermédiaire vers n'importe quelle commande afin d'effectuer la somme finale. J'ai toujours utilisé expr dans le passé, mais à moins qu'il ne fonctionne en mode RPN, je ne pense pas qu'il puisse faire face à cette situation (et même dans ce cas, ce serait délicat).

Comment obtenir la somme de nombres entiers ?

Answer 1

Un peu d'awk devrait suffire ?

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

Note : certaines versions de awk ont des comportements étranges si vous devez ajouter quelque chose qui dépasse 2^31 (2147483647). Voir les commentaires pour plus de détails. Une suggestion est d'utiliser printf plutôt que print :

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

Answer 2

Le collage permet généralement de fusionner les lignes de plusieurs fichiers, mais il peut également être utilisé pour convertir des lignes individuelles d'un fichier en une seule ligne. Le drapeau délimiteur vous permet de passer une équation de type x+x à bc.

paste -s -d+ infile | bc

Alternativement, lors de l'utilisation de la pipette à partir de stdin,

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

Answer 3

La version en ligne en Python :

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

Answer 4

Simple bash :

$ 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

Answer 5

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

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

Edit : Puisque cette réponse a reçu tant 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

Sous forme de pseudo-code :

1. Définir "add_top_of_stack" comme :
   1. Retirer les deux valeurs supérieures de la pile et ajouter le résultat.
   2. Si la pile comporte deux valeurs ou plus, exécuter "add_top_of_stack" de manière récursive.
2. Si la pile comporte deux valeurs ou plus, exécuter "add_top_of_stack"
3. Imprimer le résultat, qui est maintenant le seul élément restant dans la pile.

Pour bien comprendre la simplicité et la puissance de dc Voici un script Python fonctionnel qui met en œuvre certaines des commandes de la rubrique dc et 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()