Wie kann ich schnell alle Zahlen in einer Datei summieren?

Ich habe eine Datei, die mehrere tausend Zahlen enthält, jede in einer eigenen Zeile:

34
42
11
6
2
99
...

Ich möchte ein Skript schreiben, das die Summe aller Zahlen in der Datei druckt. Ich habe eine Lösung, aber sie ist nicht sehr effizient. (Die Ausführung dauert einige Minuten.) Ich suche nach einer effizienteren Lösung. Irgendwelche Vorschläge?

Für einen Perl-Einzeiler ist es im Grunde dasselbe wie die awkLösung in Ayman Houriehs Antwort :

 % perl -nle '$sum += $_ } END { print $sum'

Wenn Sie neugierig sind, was Perl-Einzeiler tun, können Sie sie trennen:

 %  perl -MO=Deparse -nle '$sum += $_ } END { print $sum'

Das Ergebnis ist eine ausführlichere Version des Programms in einer Form, die niemand alleine schreiben würde:

BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined($_ = <ARGV>)) {
    chomp $_;
    $sum += $_;
}
sub END {
    print $sum;
}
-e syntax OK

Nur zum Kichern habe ich dies mit einer Datei versucht, die 1.000.000 Zahlen enthält (im Bereich von 0 bis 9.999). Auf meinem Mac Pro kehrt es praktisch sofort zurück. Das ist schade, denn ich hatte gehofft, dass die Verwendung mmapsehr schnell sein würde, aber es ist genau die gleiche Zeit:

use 5.010;
use File::Map qw(map_file);

map_file my $map, $ARGV[0];

$sum += $1 while $map =~ m/(\d+)/g;

say $sum;

Sie können awk verwenden:

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

Keine der bisher verwendeten Lösungen paste. Hier ist eine:

paste -sd+ filename | bc

Berechnen Sie als Beispiel Σn, wobei 1 <= n <= 100000:

$ seq 100000 | paste -sd+ | bc -l
5000050000

(Für Neugierige seq nwürde eine Folge von Zahlen von 1bis zu neiner positiven Zahl gedruckt n.)

Lassen Sie es uns zum Spaß vergleichen:

$ for ((i=0; i<1000000; i++)) ; do echo $RANDOM; done > random_numbers

$ time perl -nle '$sum += $_ } END { print $sum' random_numbers
16379866392

real    0m0.226s
user    0m0.219s
sys     0m0.002s

$ time awk '{ sum += $1 } END { print sum }' random_numbers
16379866392

real    0m0.311s
user    0m0.304s
sys     0m0.005s

$ time { { tr "\n" + < random_numbers ; echo 0; } | bc; }
16379866392

real    0m0.445s
user    0m0.438s
sys     0m0.024s

$ time { s=0;while read l; do s=$((s+$l));done<random_numbers;echo $s; }
16379866392

real    0m9.309s
user    0m8.404s
sys     0m0.887s

$ time { s=0;while read l; do ((s+=l));done<random_numbers;echo $s; }
16379866392

real    0m7.191s
user    0m6.402s
sys     0m0.776s

$ time { sed ':a;N;s/\n/+/;ta' random_numbers|bc; }
^C

real    4m53.413s
user    4m52.584s
sys 0m0.052s

Ich habe den Sed-Lauf nach 5 Minuten abgebrochen

Ich habe getaucht luaund es ist schnell:

$ time lua -e 'sum=0; for line in io.lines() do sum=sum+line end; print(sum)' < random_numbers
16388542582.0

real    0m0.362s
user    0m0.313s
sys     0m0.063s

und während ich das aktualisiere, Ruby:

$ time ruby -e 'sum = 0; File.foreach(ARGV.shift) {|line| sum+=line.to_i}; puts sum' random_numbers
16388542582

real    0m0.378s
user    0m0.297s
sys     0m0.078s

Beachten Sie den Rat von Ed Morton: Verwenden $1

$ time awk '{ sum += $1 } END { print sum }' random_numbers
16388542582

real    0m0.421s
user    0m0.359s
sys     0m0.063s

vs mit $0

$ time awk '{ sum += $0 } END { print sum }' random_numbers
16388542582

real    0m0.302s
user    0m0.234s
sys     0m0.063s

Eine andere Option ist jq:

$ seq 10|jq -s add
55

-s( --slurp) liest die Eingabezeilen in ein Array.

Das ist gerade Bash:

sum=0
while read -r line
do
    (( sum += line ))
done < file
echo $sum

Hier ist ein weiterer Einzeiler

( echo 0 ; sed 's/$/ +/' foo ; echo p ) | dc

Dies setzt voraus, dass die Zahlen ganze Zahlen sind. Wenn Sie Dezimalstellen benötigen, versuchen Sie es

( echo 0 2k ; sed 's/$/ +/' foo ; echo p ) | dc

Stellen Sie 2 auf die Anzahl der benötigten Dezimalstellen ein.

Ich bevorzuge die Verwendung von GNU-Datamash für solche Aufgaben, da es prägnanter und lesbarer ist als Perl oder Awk. Beispielsweise

datamash sum 1 < myfile

wobei 1 die erste Datenspalte bezeichnet.

$ perl -MList::Util=sum -le 'print sum <>' nums.txt

Ich bevorzuge es, R dafür zu verwenden:

$ R -e 'sum(scan("filename"))'

cat nums | perl -ne '$sum += $_ } { print $sum'

(wie brian d foys antwort, ohne 'END')

Prägnanter:

# Ruby
ruby -e 'puts open("random_numbers").map(&:to_i).reduce(:+)'

# Python
python -c 'print(sum(int(l) for l in open("random_numbers")))'

Perl 6

say sum lines

~$ perl6 -e '.say for 0..1000000' > test.in

~$ perl6 -e 'say sum lines' < test.in
500000500000

Nur zum Spaß, machen wir es mit PDL , Perls Array-Mathe-Engine!

perl -MPDL -E 'say rcols(shift)->sum' datafile

rcolsliest Spalten in eine Matrix (in diesem Fall 1D) und sumsummiert (überraschend) das gesamte Element der Matrix.

Hier ist eine Lösung mit Python mit einem Generatorausdruck. Getestet mit einer Million Nummern auf meinem alten, groben Laptop.

time python -c "import sys; print sum((float(l) for l in sys.stdin))" < file

real    0m0.619s
user    0m0.512s
sys     0m0.028s

Ich konnte nicht einfach vorbeikommen ... Hier ist mein Haskell Einzeiler. Es ist eigentlich gut lesbar:

sum <$> (read <$>) <$> lines <$> getContents

Leider gibt es keine Möglichkeit, es ghci -eeinfach auszuführen, daher benötigt es die Hauptfunktion, Drucken und Kompilieren.

main = (sum <$> (read <$>) <$> lines <$> getContents) >>= print

Zur Verdeutlichung lesen wir die gesamte Eingabe ( getContents), teilen sie durch lines, readals Zahlen und sum. <$>ist fmapOperator - wir verwenden ihn anstelle der üblichen Funktionsanwendung, da dies alles sicher in IO geschieht. readbraucht eine zusätzliche fmap, da es auch in der Liste ist.

$ ghc sum.hs
[1 of 1] Compiling Main             ( sum.hs, sum.o )
Linking sum ...
$ ./sum 
1
2
4
^D
7

Hier ist ein seltsames Upgrade, damit es mit Floats funktioniert:

main = ((0.0 + ) <$> sum <$> (read <$>) <$> lines <$> getContents) >>= print

$ ./sum 
1.3
2.1
4.2
^D
7.6000000000000005

sed ':a;N;s/\n/+/;ta' file|bc

Ausführen von R-Skripten

Ich habe ein R-Skript geschrieben, um Argumente eines Dateinamens zu übernehmen und die Zeilen zu summieren.

#! /usr/local/bin/R
file=commandArgs(trailingOnly=TRUE)[1]
sum(as.numeric(readLines(file)))

Dies kann mit dem Paket "data.table" oder "vroom" wie folgt beschleunigt werden:

#! /usr/local/bin/R
file=commandArgs(trailingOnly=TRUE)[1]
sum(data.table::fread(file))

#! /usr/local/bin/R
file=commandArgs(trailingOnly=TRUE)[1]
sum(vroom::vroom(file))

Benchmarking

Gleiche Benchmarking-Daten wie @glenn jackman .

for ((i=0; i<1000000; i++)) ; do echo $RANDOM; done > random_numbers

Im Vergleich zum obigen R-Aufruf ist das Ausführen von R 3.5.0 als Skript mit anderen Methoden vergleichbar (auf demselben Linux-Debian-Server).

$ time R -e 'sum(scan("random_numbers"))'  
 0.37s user
 0.04s system
 86% cpu
 0.478 total

R-Skript mit readLines

$ time Rscript sum.R random_numbers
  0.53s user
  0.04s system
  84% cpu
  0.679 total

R-Skript mit data.table

$ time Rscript sum.R random_numbers     
 0.30s user
 0.05s system
 77% cpu
 0.453 total

R-Skript mit vroom

$ time Rscript sum.R random_numbers     
  0.54s user 
  0.11s system
  93% cpu
  0.696 total

Vergleich mit anderen Sprachen

Als Referenz hier einige andere Methoden, die auf derselben Hardware vorgeschlagen wurden

Python 2 (2.7.13)

$ time python2 -c "import sys; print sum((float(l) for l in sys.stdin))" < random_numbers 
 0.27s user 0.00s system 89% cpu 0.298 total

Python 3 (3.6.8)

$ time python3 -c "import sys; print(sum((float(l) for l in sys.stdin)))" < random_number
0.37s user 0.02s system 98% cpu 0.393 total

Ruby (2.3.3)

$  time ruby -e 'sum = 0; File.foreach(ARGV.shift) {|line| sum+=line.to_i}; puts sum' random_numbers
 0.42s user
 0.03s system
 72% cpu
 0.625 total

Perl (5.24.1)

$ time perl -nle '$sum += $_ } END { print $sum' random_numbers
 0.24s user
 0.01s system
 99% cpu
 0.249 total

Awk (4.1.4)

$ time awk '{ sum += $0 } END { print sum }' random_numbers
 0.26s user
 0.01s system
 99% cpu
 0.265 total
$ time awk '{ sum += $1 } END { print sum }' random_numbers
 0.34s user
 0.01s system
 99% cpu
 0.354 total

C (Clang-Version 3.3; gcc (Debian 6.3.0-18) 6.3.0)

 $ gcc sum.c -o sum && time ./sum < random_numbers   
 0.10s user
 0.00s system
 96% cpu
 0.108 total

Update mit weiteren Sprachen

Lua (5.3.5)

$ time lua -e 'sum=0; for line in io.lines() do sum=sum+line end; print(sum)' < random_numbers 
 0.30s user 
 0.01s system
 98% cpu
 0.312 total

tr (8.26) muss in bash zeitgesteuert sein und ist nicht mit zsh kompatibel

$time { { tr "\n" + < random_numbers ; echo 0; } | bc; }
real    0m0.494s
user    0m0.488s
sys 0m0.044s

sed (4.4) muss in bash zeitgesteuert sein und ist nicht mit zsh kompatibel

$  time { head -n 10000 random_numbers | sed ':a;N;s/\n/+/;ta' |bc; }
real    0m0.631s
user    0m0.628s
sys     0m0.008s
$  time { head -n 100000 random_numbers | sed ':a;N;s/\n/+/;ta' |bc; }
real    1m2.593s
user    1m2.588s
sys     0m0.012s

Hinweis: sed-Aufrufe scheinen auf Systemen mit mehr verfügbarem Speicher schneller zu funktionieren (beachten Sie kleinere Datensätze, die für das Benchmarking von sed verwendet werden).

Julia (0,5,0)

$ time julia -e 'print(sum(readdlm("random_numbers")))'
 3.00s user 
 1.39s system 
 136% cpu 
 3.204 total
$  time julia -e 'print(sum(readtable("random_numbers")))'
 0.63s user 
 0.96s system 
 248% cpu 
 0.638 total

Beachten Sie, dass Datei-E / A-Methoden wie in R eine unterschiedliche Leistung aufweisen.

C ++ "Einzeiler":

#include <iostream>
#include <iterator>
#include <numeric>
using namespace std;

int main() {
    cout << accumulate(istream_iterator<int>(cin), istream_iterator<int>(), 0) << endl;
}

Ein anderer zum Spaß

sum=0;for i in $(cat file);do sum=$((sum+$i));done;echo $sum

oder nur eine andere Bash

s=0;while read l; do s=$((s+$l));done<file;echo $s

Aber awk Lösung ist wahrscheinlich am besten, da es am kompaktesten ist.

C gewinnt immer für Geschwindigkeit:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
    ssize_t read;
    char *line = NULL;
    size_t len = 0;
    double sum = 0.0;

    while (read = getline(&line, &len, stdin) != -1) {
        sum += atof(line);
    }

    printf("%f", sum);
    return 0;
}

Timing für 1M-Nummern (gleiche Maschine / Eingabe wie meine Python-Antwort):

$ gcc sum.c -o sum && time ./sum < numbers 
5003371677.000000
real    0m0.188s
user    0m0.180s
sys     0m0.000s

Mit Ruby:

ruby -e "File.read('file.txt').split.inject(0){|mem, obj| mem += obj.to_f}"

Ich weiß nicht, ob Sie viel besser werden können, wenn man bedenkt, dass Sie die gesamte Datei durchlesen müssen.

$sum = 0;
while(<>){
   $sum += $_;
}
print $sum;

Ich habe dies nicht getestet, aber es sollte funktionieren:

cat f | tr "\n" "+" | sed 's/+$/\n/' | bc

Möglicherweise müssen Sie dem String vor bc "\ n" hinzufügen (wie über Echo), wenn bc EOF und EOL nicht behandelt ...

Hier ist ein anderes:

open(FIL, "a.txt");

my $sum = 0;
foreach( <FIL> ) {chomp; $sum += $_;}

close(FIL);

print "Sum = $sum\n";

Sie können dies mit Alacon tun - dem Befehlszeilenprogramm für die Alasql- Datenbank.

Es funktioniert mit Node.js, daher müssen Sie Node.js und dann das Alasql- Paket installieren :

Um die Summe aus der TXT-Datei zu berechnen, können Sie den folgenden Befehl verwenden:

> node alacon "SELECT VALUE SUM([0]) FROM TXT('mydata.txt')"

Es ist nicht einfacher, alle neuen Zeilen durch zu ersetzen +, eine hinzuzufügen 0und an den RubyDolmetscher zu senden ?

(sed -e "s/$/+/" file; echo 0)|irb

Wenn Sie nicht haben irb, können Sie es an senden bc, aber Sie müssen alle Zeilenumbrüche außer dem letzten (von echo) entfernen . Es ist besser, trdies zu verwenden, es sei denn, Sie haben einen Doktortitel in sed.

(sed -e "s/$/+/" file|tr -d "\n"; echo 0)|bc

In Go:

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    sum := int64(0)
    for scanner.Scan() {
        v, err := strconv.ParseInt(scanner.Text(), 10, 64)
        if err != nil {
            fmt.Fprintf(os.Stderr, "Not an integer: '%s'\n", scanner.Text())
            os.Exit(1)
        }
        sum += v
    }
    fmt.Println(sum)
}

Bash-Variante

raw=$(cat file)
echo $(( ${raw//$'\n'/+} ))

$ wc -l file
10000 file

$ time ./test
323390

real    0m3,096s
user    0m3,095s
sys     0m0,000s

In der Shell mit awk habe ich das folgende Skript verwendet, um dies zu tun:

    #!/bin/bash


total=0;

for i in $( awk '{ print $1; }' <myfile> )
do
 total=$(echo $total+$i | bc )
 ((count++))
done
echo "scale=2; $total " | bc