Comando Shell per sommare numeri interi, uno per riga?

Sto cercando un comando che accetti (come input) più righe di testo, ciascuna contenente un singolo numero intero e produca la somma di questi numeri interi.

Come sfondo, ho un file di registro che include misure di temporizzazione. Attraverso il grepping per le righe pertinenti e un po 'di sedriformattazione posso elencare tutti i tempi in quel file. Vorrei calcolare il totale. Posso inoltrare questo output intermedio a qualsiasi comando per fare la somma finale. L'ho sempre usatoexpr in passato, ma a meno che non funzioni in modalità RPN, non penso che riuscirà a farcela (e anche in questo caso sarebbe difficile).

Come posso ottenere la somma degli interi?

Un po 'di imbarazzo dovrebbe farlo?

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

Nota: alcune versioni di awk hanno comportamenti strani se si intende aggiungere qualcosa che supera 2 ^ 31 (2147483647). Vedi i commenti per ulteriori informazioni. Un suggerimento è di utilizzare printfpiuttosto che print:

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

In genere, Incolla unisce linee di più file, ma può anche essere utilizzata per convertire singole linee di un file in una singola riga. Il flag delimitatore consente di passare un'equazione di tipo x + x a bc.

paste -s -d+ infile | bc

In alternativa, quando si esegue il piping da stdin,

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

La versione one-liner in Python:

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

Vorrei mettere un grande AVVISO sulla soluzione comunemente approvata:

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

questo perché in questa forma awk utilizza una rappresentazione intera con segno a 32 bit: trabocca per somme che superano 2147483647 (ovvero 2 ^ 31).

Una risposta più generale (per sommare numeri interi) sarebbe:

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

Bash semplice:

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

Si noti che i numeri negativi con prefisso con il segno meno devono essere tradotti per dc, poiché utilizza il _prefisso anziché il -prefisso per quello. Ad esempio, tramite tr '-' '_' | dc -f- -e '...'.

Modifica: poiché questa risposta ha ottenuto così tanti voti "per oscurità", ecco una spiegazione dettagliata:

L'espressione [+z1<r]srz1<rp procede come segue :

[   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

Come pseudo-codice:

1. Definisci "add_top_of_stack" come:
   1. Rimuovere i due valori principali dallo stack e aggiungere nuovamente il risultato
   2. Se lo stack ha due o più valori, eseguire "add_top_of_stack" in modo ricorsivo
2. Se lo stack ha due o più valori, eseguire "add_top_of_stack"
3. Stampa il risultato, ora l'unico elemento rimasto nella pila

Per comprendere davvero la semplicità e la potenza di dc, ecco uno script Python funzionante che implementa alcuni dei comandi da dced esegue una versione Python del comando sopra:

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

Bash puro e corto.

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

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

I miei quindici centesimi:

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

Esempio:

$ 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

Ho fatto un rapido benchmark sulle risposte esistenti che

• usa solo strumenti standard (scusami per cose come luao rocket),
• sono veri e propri liner,
• sono in grado di aggiungere enormi quantità di numeri (100 milioni) e
• sono veloci (ho ignorato quelli che hanno impiegato più di un minuto).

Ho sempre aggiunto i numeri da 1 a 100 milioni, fattibile sulla mia macchina in meno di un minuto per diverse soluzioni.

Ecco i risultati:

Pitone

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

Incolla & Bc

Questo ha esaurito la memoria sulla mia macchina. Ha funzionato per metà delle dimensioni dell'input (50 milioni di numeri):

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

Quindi immagino che ci sarebbero voluti circa 35 secondi per i 100 milioni di numeri.

Perl

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

Rubino

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

C

Per fare un confronto, ho compilato la versione C e ho provato anche questo, solo per avere un'idea di quanto siano lente le soluzioni basate su strumenti.

#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

Conclusione

C è ovviamente il più veloce con 8s, ma la soluzione Pypy aggiunge solo un overhead molto piccolo di circa il 30% a 11s . Ma, per essere onesti, Pypy non è esattamente standard. La maggior parte delle persone ha solo CPython installato che è significativamente più lento (22s), esattamente come la popolare soluzione Awk.

La soluzione più veloce basata su strumenti standard è Perl (15s).

Bash semplice una fodera

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

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

Soluzione BASH, se vuoi rendere questo un comando (ad esempio se devi farlo frequentemente):

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

Quindi utilizzo:

addnums < /tmp/nums

Penso che AWK sia ciò che stai cercando:

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

È possibile utilizzare questo comando passando l'elenco dei numeri attraverso l'input standard o passando il file contenente i numeri come parametro.

Il seguente funziona in bash:

I=0

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

echo $I

Puoi usare num-utils, anche se potrebbe essere eccessivo per quello che ti serve. Questo è un insieme di programmi per manipolare i numeri nella shell e può fare diverse cose ingegnose, incluso ovviamente aggiungerle. È un po 'obsoleto, ma funzionano ancora e possono essere utili se devi fare qualcosa di più.

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

Mi rendo conto che questa è una vecchia domanda, ma mi piace questa soluzione abbastanza per condividerla.

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

Se c'è interesse, ti spiego come funziona.

Bash puro e in una sola riga :-)

$ 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, abbastanza leggibile, non sono richiesti pacchetti o opzioni:

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

Per gli amanti del rubino

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

Non puoi evitare di inviarlo:

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

Si trova qui: il
più elegante one-liner shell unix per sommare un elenco di numeri di precisione arbitraria?

E qui ci sono i suoi vantaggi speciali rispetto a awk, bc e amici:

• non dipende dal buffering e quindi non si strozza con input veramente grandi
• non implica alcuna precisione particolare o dimensione intera per i limiti della materia
• non è necessario un codice diverso, se è necessario aggiungere numeri in virgola mobile

Utilizzando l' utilità GNU datamash :

seq 10 | datamash sum 1

Produzione:

55

Se i dati di input sono irregolari, con spazi e schede in punti dispari, ciò può confondere datamash, quindi utilizzare l' -Winterruttore:

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

... o usa trper pulire gli spazi bianchi:

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

La mia versione:

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

Puoi farlo in Python, se ti senti a tuo agio:

Non testato, appena digitato:

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

Sebastian ha sottolineato una sceneggiatura da una riga:

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

Oppure, puoi digitare i numeri sulla riga di comando:

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

Tuttavia, questo assorbe il file, quindi non è una buona idea usare su file di grandi dimensioni. Vedi la risposta di j_random_hacker che evita lo slurping.

Il seguente dovrebbe funzionare (supponendo che il tuo numero sia il secondo campo su ogni riga).

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

One-liner in racchetta:

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

C (non semplificato)

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)

Mi scuso in anticipo per la leggibilità dei backtick ("` "), ma questi funzionano in shell diverse da bash e sono quindi più incollabili. Se usi una shell che lo accetta, il formato $ (comando ...) è molto più leggibile (e quindi debuggable) di `comando ...`, quindi sentiti libero di modificare per la tua sanità mentale.

Ho una semplice funzione nel mio bashrc che utilizzerà awk per calcolare una serie di semplici elementi matematici

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

Questo farà +, -, *, /, ^,%, sqrt, sin, cos, parentesi .... (e altro a seconda della tua versione di awk) ... potresti persino immaginarti con printf e il formato in virgola mobile output, ma questo è tutto ciò di cui normalmente ho bisogno

per questa domanda particolare, lo farei semplicemente per ogni riga:

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

quindi il blocco di codice per sommare ogni riga sarebbe simile a questo:

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

Questo se volessi sommarli solo riga per riga. Tuttavia, per un totale di ogni numero nel file di dati

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

a proposito se devo fare qualcosa di veloce sul desktop, uso questo:

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