Polecenie powłoki sumujące liczby całkowite, po jednym w wierszu?

Szukam polecenia, które zaakceptuje (jako dane wejściowe) wiele wierszy tekstu, z których każdy zawiera jedną liczbę całkowitą, i wyświetli sumę tych liczb całkowitych.

Jako trochę tła mam plik dziennika, który zawiera pomiary czasu. Poprzez grepping dla odpowiednich wierszy i trochę sedprzeformatowania mogę wymienić wszystkie czasy w tym pliku. Chciałbym obliczyć sumę. Mogę przesłać to wyjście pośrednie do dowolnego polecenia w celu dokonania ostatecznej sumy. Zawsze używałem exprw przeszłości, ale chyba, że ​​działa w trybie RPN, nie sądzę, że sobie z tym poradzi (i nawet wtedy byłoby to trudne).

Jak mogę uzyskać sumowanie liczb całkowitych?

Trochę awk powinien to zrobić?

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

Uwaga: niektóre wersje awk mają dziwne zachowania, jeśli zamierzasz dodać coś przekraczającego 2 ^ 31 (2147483647). Zobacz komentarze, aby uzyskać więcej informacji. Jedną z sugestii jest użycie printfzamiast print:

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

Wklej zazwyczaj łączy wiersze wielu plików, ale można go również użyć do konwersji pojedynczych wierszy pliku w jeden wiersz. Flaga separatora pozwala przekazać równanie typu x + x do bc.

paste -s -d+ infile | bc

Alternatywnie, gdy wykonujesz orurowanie ze standardowego wejścia,

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

Wersja jednoliniowa w Pythonie:

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

Złożyłbym duże OSTRZEŻENIE na powszechnie akceptowane rozwiązanie:

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

to dlatego, że w tej formie awk używa 32-bitowej reprezentacji liczb całkowitych ze znakiem: przepełni się dla sum przekraczających 2147483647 (tj. 2 ^ 31).

Bardziej ogólną odpowiedzią (dla sumowania liczb całkowitych) byłoby:

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

Zwykły 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'

Zauważ, że liczby ujemne poprzedzone znakiem minus powinny zostać przetłumaczone dc, ponieważ używa do tego _raczej -prefiksu niż prefiksu. Na przykład przez tr '-' '_' | dc -f- -e '...'.

Edycja: Ponieważ ta odpowiedź uzyskała tyle głosów „za niejasnością”, oto szczegółowe wyjaśnienie:

Wyrażenie [+z1<r]srz1<rp wykonuje następujące czynności :

[   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

Jako pseudo-kod:

1. Zdefiniuj „add_top_of_stack” jako:
   1. Usuń dwie najwyższe wartości ze stosu i dodaj wynik z powrotem
   2. Jeśli stos ma dwie lub więcej wartości, uruchom rekurencyjnie polecenie „add_top_of_stack”
2. Jeśli stos ma dwie lub więcej wartości, uruchom polecenie „add_top_of_stack”
3. Wydrukuj wynik, teraz jedyny element pozostały na stosie

Aby naprawdę zrozumieć prostotę i moc dc, oto działający skrypt Pythona, który implementuje niektóre polecenia z dci wykonuje wersję powyższego polecenia w języku Python:

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

Z jq :

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

Czysty i krótki bash.

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

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

Moje piętnaście centów:

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

Przykład:

$ 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

Zrobiłem szybki test porównawczy na istniejące odpowiedzi, które

• używaj tylko standardowych narzędzi (przepraszam za rzeczy takie jak lualubrocket ),
• są prawdziwymi liniowcami,
• są w stanie dodać ogromne ilości liczb (100 milionów), oraz
• są szybkie (zignorowałem te, które trwały dłużej niż minutę).

Zawsze dodawałem liczby od 1 do 100 milionów, które były możliwe do wykonania na mojej maszynie w mniej niż minutę dla kilku rozwiązań.

Oto wyniki:

Pyton

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

Wklej i Bc

Na mojej maszynie zabrakło pamięci. To działało dla połowy wielkości wejściowej (50 milionów liczb):

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

Sądzę więc, że zajęłoby to około 35 sekund dla 100 milionów liczb.

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

do

Dla porównania, skompilowałem wersję C i przetestowałem ją również, aby zorientować się, o ile wolniejsze są rozwiązania oparte na narzędziach.

#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

Wniosek

C jest oczywiście najszybszy z 8s, ale rozwiązanie Pypy dodaje tylko niewielki narzut około 30% do 11s . Ale, szczerze mówiąc, Pypy nie jest dokładnie standardem. Większość ludzi ma zainstalowany tylko CPython, który jest znacznie wolniejszy (22 s), dokładnie tak szybko, jak popularne rozwiązanie Awk.

Najszybszym rozwiązaniem opartym na standardowych narzędziach jest Perl (15s).

Prosta podszewka z jedną wkładką

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

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

Rozwiązanie BASH, jeśli chcesz ustawić to jako polecenie (np. Jeśli musisz to robić często):

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

Następnie użycie:

addnums < /tmp/nums

Myślę, że AWK jest tym, czego szukasz:

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

Możesz użyć tego polecenia albo przez przekazanie listy liczb przez standardowe wejście, albo przez przekazanie pliku zawierającego liczby jako parametru.

Następujące działa w bash:

I=0

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

echo $I

Możesz używać num-utils, chociaż może to być przesada w stosunku do tego, czego potrzebujesz. Jest to zestaw programów do manipulowania liczbami w powłoce i może robić kilka fajnych rzeczy, w tym oczywiście dodawać je. To trochę nieaktualne, ale nadal działają i mogą być przydatne, jeśli chcesz zrobić coś więcej.

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

Zdaję sobie sprawę, że to stare pytanie, ale podoba mi się to rozwiązanie, aby je udostępnić.

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

Jeśli jest zainteresowanie, wyjaśnię, jak to działa.

Pure Bash w jednej linijce :-)

$ 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

Alternatywny czysty Perl, dość czytelny, nie wymaga żadnych pakietów ani opcji:

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

Dla miłośników rubinów

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

Nie można uniknąć przesłania tego:

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

Można go znaleźć tutaj:
najbardziej elegancki jednowarstwowy płaszcz unixowy do sumowania liczb o dowolnej precyzji?

A oto jego szczególne zalety w stosunku do awk, bc i przyjaciół:

• nie zależy od buforowania, a zatem nie dusi się przy naprawdę dużych wejściach
• nie implikuje żadnej szczególnej precyzji ani wielkości całkowitych dla tego limitu materii
• nie ma potrzeby stosowania innego kodu, jeśli trzeba dodać liczby zmiennoprzecinkowe

Korzystanie z GNU datamash util :

seq 10 | datamash sum 1

Wynik:

55

Jeśli dane wejściowe są nieregularne, ze spacjami i tabulatorami w nieparzystych miejscach, może to mylić datamash, a następnie użyj -Wprzełącznika:

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

... lub użyj trdo wyczyszczenia białych znaków:

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

Moja wersja:

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

Możesz to zrobić w pythonie, jeśli czujesz się komfortowo:

Nie testowane, po prostu wpisane:

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

Sebastian wskazał jeden skrypt liniowy:

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

Lub możesz wpisać liczby w wierszu poleceń:

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

Jednak ten plik sluruje plik, więc nie jest dobrym pomysłem stosowanie do dużych plików. Zobacz odpowiedź j_random_hackera, która pozwala uniknąć osiadania.

Poniższe powinno działać (zakładając, że Twój numer jest drugim polem w każdej linii).

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

One-liner in Racket:

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

C (nie uproszczony)

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)

Z góry przepraszamy za czytelność tylnych kresek („'”), ale działają one w powłokach innych niż bash, a zatem są łatwiejsze do wklejenia. Jeśli używasz powłoki, która ją akceptuje, format $ (polecenie ...) jest znacznie bardziej czytelny (a przez to debugowalny) niż `polecenie ... ', więc możesz modyfikować dla własnego zdrowia psychicznego.

Mam prostą funkcję w moim bashrc, która użyje awk do obliczenia liczby prostych elementów matematycznych

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

To zrobi +, -, *, /, ^,%, sqrt, sin, cos, nawias ... (i więcej w zależności od twojej wersji awk) ... możesz nawet się spodobać z printf i formatem zmiennoprzecinkowym wyjście, ale to wszystko, czego zwykle potrzebuję

w przypadku tego konkretnego pytania po prostu zrobiłbym to dla każdej linii:

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

więc blok kodu sumujący każdą linię wyglądałby mniej więcej tak:

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

To jest, jeśli chcesz sumować je tylko linia po linii. Jednak w sumie dla każdej liczby w pliku danych

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

btw, jeśli muszę zrobić coś szybko na pulpicie, używam tego:

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