Lệnh Shell để tính tổng số nguyên, mỗi dòng trên một dòng?

Tôi đang tìm kiếm một lệnh sẽ chấp nhận (làm đầu vào) nhiều dòng văn bản, mỗi dòng chứa một số nguyên duy nhất và xuất tổng của các số nguyên này.

Một chút về nền tảng, tôi có một tệp nhật ký bao gồm các phép đo thời gian. Thông qua việc grepping cho các dòng có liên quan và một chút sedđịnh dạng lại, tôi có thể liệt kê tất cả các thời gian trong tập tin đó. Tôi muốn làm việc ra tổng số. Tôi có thể chuyển đầu ra trung gian này tới bất kỳ lệnh nào để thực hiện tổng cuối cùng. Tôi đã luôn sử dụng exprtrong quá khứ, nhưng trừ khi nó chạy ở chế độ RPN, tôi không nghĩ rằng nó sẽ đối phó với điều này (và thậm chí sau đó nó sẽ rất khó khăn).

Làm thế nào tôi có thể có được tổng các số nguyên?

Bit của awk nên làm gì?

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

Lưu ý: một số phiên bản của awk có một số hành vi kỳ quặc nếu bạn định thêm bất cứ thứ gì vượt quá 2 ^ 31 (2147483647). Xem bình luận để có thêm nền tảng. Một gợi ý là sử dụng printfchứ không phải print:

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

Dán thường hợp nhất các dòng của nhiều tệp, nhưng nó cũng có thể được sử dụng để chuyển đổi các dòng riêng lẻ của một tệp thành một dòng duy nhất. Cờ phân cách cho phép bạn truyền phương trình loại x + x cho bc.

paste -s -d+ infile | bc

Ngoài ra, khi đường ống từ stdin,

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

Phiên bản một lớp trong Python:

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

Tôi sẽ đặt một CẢNH BÁO lớn cho giải pháp thường được phê duyệt:

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

đó là bởi vì trong hình thức này, awk sử dụng biểu diễn số nguyên có chữ ký 32 bit: nó sẽ tràn cho các khoản tiền vượt quá 2147483647 (tức là, 2 ^ 31).

Một câu trả lời tổng quát hơn (để tính tổng các số nguyên) sẽ là:

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

Bash đơn giản:

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

Lưu ý rằng các số âm có tiền tố với dấu trừ nên được dịch cho dc, vì nó sử dụng _tiền tố thay vì -tiền tố cho điều đó. Ví dụ, thông qua tr '-' '_' | dc -f- -e '...'.

Chỉnh sửa: Vì câu trả lời này đã nhận được rất nhiều phiếu "cho sự tối nghĩa", đây là một lời giải thích chi tiết:

Biểu thức [+z1<r]srz1<rp thực hiện như sau :

[   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

Như mã giả:

1. Xác định "add_top_of_stack" là:
   1. Xóa hai giá trị trên cùng khỏi ngăn xếp và thêm kết quả trở lại
   2. Nếu ngăn xếp có hai hoặc nhiều giá trị, hãy chạy "add_top_of_stack" theo cách đệ quy
2. Nếu ngăn xếp có hai hoặc nhiều giá trị, hãy chạy "add_top_of_stack"
3. In kết quả, bây giờ là mục duy nhất còn lại trong ngăn xếp

Để thực sự hiểu được sự đơn giản và sức mạnh của dc, đây là một kịch bản Python đang hoạt động thực hiện một số lệnh từ dcvà thực thi một phiên bản Python của lệnh trên:

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

Với jq :

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

Bash tinh khiết và ngắn.

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

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

Mười lăm xu của tôi:

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

Thí dụ:

$ 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

Tôi đã thực hiện một điểm chuẩn nhanh về các câu trả lời hiện có

• chỉ sử dụng các công cụ tiêu chuẩn (xin lỗi cho những thứ như luahoặc rocket),
• là một lớp lót thực sự,
• có khả năng thêm số lượng lớn (100 triệu) và
• rất nhanh (tôi bỏ qua những cái mất nhiều hơn một phút).

Tôi luôn thêm các con số từ 1 đến 100 triệu có thể thực hiện được trên máy của mình trong chưa đầy một phút cho một số giải pháp.

Đây là kết quả:

Con trăn

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

Dán & Bc

Điều này đã hết bộ nhớ trên máy của tôi. Nó hoạt động với một nửa kích thước của đầu vào (50 triệu số):

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

Vì vậy, tôi đoán nó sẽ mất ~ 35 giây cho 100 triệu số.

Perl

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

Hồng ngọc

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

C

Chỉ để so sánh, tôi đã biên soạn phiên bản C và cũng đã thử nghiệm điều này, chỉ để có ý tưởng về các giải pháp dựa trên công cụ chậm hơn bao nhiêu.

#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

Phần kết luận

C tất nhiên là nhanh nhất với 8 giây , nhưng giải pháp Pypy chỉ thêm rất ít chi phí khoảng 30% đến 11 giây . Nhưng, công bằng mà nói, Pypy không chính xác theo tiêu chuẩn. Hầu hết mọi người chỉ cài đặt CPython chậm hơn đáng kể (22s), nhanh chính xác như giải pháp Awk phổ biến.

Giải pháp nhanh nhất dựa trên các công cụ tiêu chuẩn là Perl (15 giây).

Plain bash một lót

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

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

Giải pháp BASH, nếu bạn muốn biến điều này thành một lệnh (ví dụ: nếu bạn cần thực hiện việc này thường xuyên):

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

Sau đó sử dụng:

addnums < /tmp/nums

Tôi nghĩ AWK là những gì bạn đang tìm kiếm:

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

Bạn có thể sử dụng lệnh này bằng cách chuyển danh sách số qua đầu vào tiêu chuẩn hoặc bằng cách chuyển tệp chứa các số làm tham số.

Các công việc sau đây trong bash:

I=0

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

echo $I

Bạn có thể sử dụng num-utils, mặc dù nó có thể quá mức cho những gì bạn cần. Đây là một bộ các chương trình để thao tác các số trong trình bao và có thể thực hiện một số điều tiện lợi, bao gồm cả việc thêm chúng vào. Hơi lỗi thời một chút, nhưng chúng vẫn hoạt động và có thể hữu ích nếu bạn cần làm gì đó nhiều hơn.

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

Tôi nhận ra đây là một câu hỏi cũ, nhưng tôi thích giải pháp này đủ để chia sẻ nó.

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

Nếu có hứng thú, tôi sẽ giải thích cách nó hoạt động.

Bash tinh khiết và trong một lớp lót :-)

$ 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 thuần thay thế, khá dễ đọc, không yêu cầu gói hoặc tùy chọn:

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

Dành cho những người yêu thích Ruby

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

Không thể tránh gửi điều này:

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

Nó được tìm thấy ở đây:
Hầu hết các lớp vỏ unix thanh lịch để tổng hợp danh sách các số chính xác tùy ý?

Và đây là những ưu điểm đặc biệt của nó so với awk, bc và bạn bè:

• nó không phụ thuộc vào bộ đệm và do đó không bị nghẹt với đầu vào thực sự lớn
• nó ngụ ý không có độ chính xác cụ thể - kích thước số nguyên cho giới hạn đó
• không cần mã khác, nếu cần thêm số dấu phẩy động

Sử dụng GNU datamash util :

seq 10 | datamash sum 1

Đầu ra:

55

Nếu dữ liệu đầu vào không đều, có khoảng trắng và tab ở những vị trí kỳ lạ, điều này có thể gây nhầm lẫn datamash, sau đó sử dụng công -Wtắc:

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

... hoặc sử dụng trđể dọn sạch khoảng trắng:

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

Phiên bản của tôi:

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

Bạn có thể làm điều đó trong python, nếu bạn cảm thấy thoải mái:

Không được kiểm tra, chỉ cần gõ:

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

Sebastian chỉ ra một kịch bản lót:

cat filename | python -c"from fileinput import input; print sum(map(int, input()))"

$ mèo n
2
4
2
7
số 8
9

$ perl -MList::Util -le 'print List::Util::sum(<>)' < n
32

Hoặc, bạn có thể nhập các số trên dòng lệnh:

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

Tuy nhiên, cái này làm lu mờ tệp nên không nên sử dụng trên các tệp lớn. Xem câu trả lời của j_random_hacker mà tránh bị nhếch nhác .

Mục sau sẽ hoạt động (giả sử số của bạn là trường thứ hai trên mỗi dòng).

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

Một lớp lót trong vợt:

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

C (không đơn giản hóa)

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)

Xin lỗi trước về khả năng đọc của backticks ("` "), nhưng chúng hoạt động trong các shell khác với bash và do đó dễ bị dán hơn. Nếu bạn sử dụng shell chấp nhận nó, định dạng $ (lệnh ...) sẽ dễ đọc hơn (và do đó có thể gỡ lỗi) hơn `lệnh ...` vì vậy hãy thoải mái sửa đổi cho sự tỉnh táo của bạn.

Tôi có một hàm đơn giản trong bashrc của mình, nó sẽ sử dụng awk để tính toán một số mục toán học đơn giản

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

Điều này sẽ làm +, -, *, /, ^,%, sqrt, sin, cos, ngoặc đơn .... (và nhiều hơn nữa tùy thuộc vào phiên bản awk của bạn) ... đầu ra, nhưng đây là tất cả những gì tôi thường cần

Đối với câu hỏi cụ thể này, tôi chỉ cần làm điều này cho mỗi dòng:

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

vì vậy khối mã để tổng hợp từng dòng sẽ trông giống như thế này:

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

Đó là nếu bạn muốn chỉ tổng hợp từng dòng một. Tuy nhiên, với tổng số mỗi số trong tệp dữ liệu

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

btw nếu tôi cần làm gì đó nhanh chóng trên máy tính để bàn, tôi sử dụng cái này:

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