Shell-Befehl zum Summieren von ganzen Zahlen, eine pro Zeile?

Ich suche nach einem Befehl, der mehrere Textzeilen (als Eingabe) akzeptiert, wobei jede Zeile eine einzelne Ganzzahl enthält, und die Summe dieser Ganzzahlen ausgibt.

Als Hintergrund habe ich eine Protokolldatei, die Timing-Messungen enthält. Durch Suchen nach den relevanten Zeilen und ein wenig sedNeuformatieren kann ich alle Timings in dieser Datei auflisten . Ich würde gerne die Summe berechnen. Ich kann diese Zwischenausgabe an jeden Befehl weiterleiten, um die endgültige Summe zu erstellen. Ich habe es exprin der Vergangenheit immer verwendet , aber wenn es nicht im RPN-Modus läuft, denke ich nicht, dass es damit fertig wird (und selbst dann wäre es schwierig).

Wie kann ich die Summe der ganzen Zahlen erhalten?

Ein bisschen awk sollte es tun?

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

Hinweis: Einige Versionen von awk weisen merkwürdige Verhaltensweisen auf, wenn Sie etwas hinzufügen, das 2 ^ 31 (2147483647) überschreitet. Weitere Hintergrundinformationen finden Sie in den Kommentaren. Ein Vorschlag ist, printfeher zu verwenden als print:

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

Beim Einfügen werden normalerweise Zeilen mehrerer Dateien zusammengeführt. Es kann jedoch auch verwendet werden, um einzelne Zeilen einer Datei in eine einzelne Zeile zu konvertieren. Mit dem Begrenzer-Flag können Sie eine Gleichung vom Typ x + x an bc übergeben.

paste -s -d+ infile | bc

Alternativ, wenn Rohrleitungen von stdin,

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

Die einzeilige Version in Python:

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

Ich würde eine große WARNUNG auf die allgemein genehmigte Lösung setzen:

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

Dies liegt daran, dass awk in dieser Form eine vorzeichenbehaftete 32-Bit-Ganzzahldarstellung verwendet: Sie läuft für Summen über, die 2147483647 (dh 2 ^ 31) überschreiten.

Eine allgemeinere Antwort (zum Summieren von ganzen Zahlen) wäre:

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

Plain 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

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

Beachten Sie, dass negative Zahlen mit Minuszeichen übersetzt werden sollten dc, da hierfür _eher ein -Präfix als ein Präfix verwendet wird. Zum Beispiel über tr '-' '_' | dc -f- -e '...'.

Bearbeiten: Da diese Antwort so viele Stimmen "für Dunkelheit" erhielt, ist hier eine detaillierte Erklärung:

Der Ausdruck [+z1<r]srz1<rp bewirkt Folgendes :

[   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

Als Pseudocode:

1. Definieren Sie "add_top_of_stack" als:
   1. Entfernen Sie die beiden oberen Werte vom Stapel und fügen Sie das Ergebnis wieder hinzu
   2. Wenn der Stapel zwei oder mehr Werte hat, führen Sie "add_top_of_stack" rekursiv aus
2. Wenn der Stapel zwei oder mehr Werte hat, führen Sie "add_top_of_stack" aus.
3. Drucken Sie das Ergebnis aus, jetzt das einzige Element im Stapel

Um die Einfachheit und Leistungsfähigkeit von wirklich zu verstehen dc, finden Sie hier ein funktionierendes Python-Skript, das einige der Befehle aus dceiner Python-Version des obigen Befehls implementiert und ausführt:

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

Mit jq :

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

Reine und kurze Bash.

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

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

Meine fünfzehn Cent:

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

Beispiel:

$ 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

Ich habe einen kurzen Benchmark für die vorhandenen Antworten durchgeführt, die

• benutze nur Standardwerkzeuge (sorry für Sachen wie luaoder rocket),
• sind echte Einzeiler,
• sind in der Lage, große Mengen von Zahlen (100 Millionen) hinzuzufügen, und
• sind schnell (ich habe diejenigen ignoriert, die länger als eine Minute gedauert haben).

Ich habe immer die Zahlen 1 bis 100 Millionen hinzugefügt, die für mehrere Lösungen in weniger als einer Minute auf meinem Computer ausgeführt werden konnten.

Hier sind die Ergebnisse:

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

Paste & Bc

Auf meinem Computer ging der Speicher aus. Es funktionierte für die Hälfte der Größe der Eingabe (50 Millionen Zahlen):

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

Ich denke, es hätte ~ 35 Sekunden für die 100 Millionen Zahlen gedauert.

Perl

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

Rubin

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

C.

Nur zum Vergleich habe ich die C-Version kompiliert und auch getestet, um eine Vorstellung davon zu bekommen, wie viel langsamer die werkzeugbasierten Lösungen sind.

#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

Fazit

C ist mit 8s natürlich am schnellsten, aber die Pypy-Lösung fügt 11s nur einen sehr geringen Overhead von etwa 30% hinzu . Aber um fair zu sein, ist Pypy nicht gerade Standard. Die meisten Leute haben nur CPython installiert, das deutlich langsamer ist (22s), genau so schnell wie die beliebte Awk-Lösung.

Die schnellste Lösung, die auf Standardwerkzeugen basiert, ist Perl (15s).

Einfach einen Liner schlagen

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

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

BASH-Lösung, wenn Sie dies zu einem Befehl machen möchten (z. B. wenn Sie dies häufig tun müssen):

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

Dann Verwendung:

addnums < /tmp/nums

Ich denke, AWK ist das, wonach Sie suchen:

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

Sie können diesen Befehl verwenden, indem Sie entweder die Zahlenliste über die Standardeingabe oder die Datei mit den Zahlen als Parameter übergeben.

Folgendes funktioniert in bash:

I=0

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

echo $I

Sie können num-utils verwenden, obwohl es für das, was Sie brauchen, möglicherweise übertrieben ist. Dies ist eine Reihe von Programmen zum Bearbeiten von Zahlen in der Shell, die mehrere raffinierte Aufgaben ausführen können, einschließlich natürlich der Addition. Es ist etwas veraltet, aber sie funktionieren immer noch und können nützlich sein, wenn Sie etwas mehr tun müssen.

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

Mir ist klar, dass dies eine alte Frage ist, aber ich mag diese Lösung genug, um sie zu teilen.

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

Bei Interesse erkläre ich, wie es funktioniert.

Pure Bash und in einem Einzeiler :-)

$ 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 reine Perl, ziemlich lesbar, keine Pakete oder Optionen erforderlich:

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

Für Rubinliebhaber

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

Ich kann es nicht vermeiden, dies einzureichen:

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

Es ist hier zu finden:
Der eleganteste Einzeiler der Unix-Shell, um die Liste der Zahlen mit beliebiger Genauigkeit zusammenzufassen?

Und hier sind seine besonderen Vorteile gegenüber awk, bc und Freunden:

• es hängt nicht von der Pufferung ab und drosselt daher nicht mit wirklich großen Eingaben
• Dies impliziert keine besondere Genauigkeit - oder Ganzzahlgröße -
• Kein anderer Code erforderlich, wenn Gleitkommazahlen hinzugefügt werden müssen

Verwenden des GNU datamash util :

seq 10 | datamash sum 1

Ausgabe:

55

Wenn die Eingabedaten unregelmäßig sind und Leerzeichen und Tabulatoren an ungeraden Stellen stehen, kann dies verwirrend datamashsein. Verwenden Sie dann entweder den -WSchalter:

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

... oder verwenden Sie tr, um das Leerzeichen zu bereinigen:

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

Meine Version:

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

Sie können es in Python tun, wenn Sie sich wohl fühlen:

Nicht getestet, nur getippt:

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

Sebastian wies auf ein Einzeilenskript hin:

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

Oder Sie können die Zahlen in der Befehlszeile eingeben:

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

Dieser schlürft jedoch die Datei, so dass es keine gute Idee ist, sie für große Dateien zu verwenden. Siehe die Antwort von j_random_hacker, die ein Schlürfen vermeidet.

Folgendes sollte funktionieren (vorausgesetzt, Ihre Nummer ist das zweite Feld in jeder Zeile).

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

Einzeiler im Schläger:

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

C (nicht vereinfacht)

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)

Entschuldigung im Voraus für die Lesbarkeit der Backticks ("` "), aber diese funktionieren in anderen Shells als Bash und sind daher besser zu verarbeiten. Wenn Sie eine Shell verwenden, die dies akzeptiert, ist das Format $ (Befehl ...) viel besser lesbar (und damit debuggbar) als "Befehl ...". Sie können es also aus Gründen der Vernunft ändern.

Ich habe eine einfache Funktion in meinem Bashrc, die awk verwendet, um eine Reihe einfacher mathematischer Elemente zu berechnen

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

Dies führt zu +, -, *, /, ^,%, sqrt, sin, cos, Klammern ... (und mehr, abhängig von Ihrer Version von awk) ... Sie könnten sogar Lust auf printf und Format-Gleitkomma haben Ausgabe, aber das ist alles, was ich normalerweise brauche

Für diese spezielle Frage würde ich dies einfach für jede Zeile tun:

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

Der Codeblock zum Summieren jeder Zeile würde also ungefähr so ​​aussehen:

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

Das ist, wenn Sie sie nur Zeile für Zeile summieren wollten. Jedoch für insgesamt jede Nummer in der Datendatei

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

Übrigens, wenn ich etwas schnell auf dem Desktop tun muss, benutze ich Folgendes:

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