คำสั่ง Shell เพื่อรวมจำนวนเต็มหนึ่งรายการต่อบรรทัดหรือไม่

ฉันกำลังมองหาคำสั่งที่จะยอมรับ (เป็นอินพุต) ข้อความหลายบรรทัดแต่ละบรรทัดมีจำนวนเต็มเดียวและส่งออกผลรวมของจำนวนเต็มเหล่านี้

เป็นพื้นหลังเล็กน้อยฉันมีไฟล์บันทึกซึ่งรวมถึงการวัดเวลา ผ่านการ grepping สำหรับบรรทัดที่เกี่ยวข้องและการsedฟอร์แมตเล็กน้อยฉันสามารถแสดงรายการการกำหนดเวลาทั้งหมดในไฟล์นั้น ฉันต้องการผลรวมทั้งหมด ฉันสามารถไพพ์เอาต์พุตกลางนี้ไปยังคำสั่งใดก็ได้เพื่อทำผลรวมสุดท้าย ฉันเคยใช้มาก่อนexprในอดีต แต่ถ้ามันไม่ทำงานในโหมด RPN ฉันไม่คิดว่ามันจะรับมือกับสิ่งนี้ (และถึงแม้มันจะยุ่งยากก็ตาม)

ฉันจะรับผลรวมของจำนวนเต็มได้อย่างไร

บิตของ awk ควรทำหรือไม่

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

หมายเหตุ: awk บางรุ่นมีพฤติกรรมแปลก ๆ บางอย่างถ้าคุณจะเพิ่มอะไรเกิน 2 ^ 31 (2147483647) ดูความคิดเห็นสำหรับพื้นหลังเพิ่มเติม หนึ่งข้อเสนอแนะคือการใช้printfมากกว่าprint:

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

วางโดยทั่วไปแล้วผสานบรรทัดของไฟล์หลาย ๆ ไฟล์ แต่ก็สามารถใช้ในการแปลงแต่ละบรรทัดของไฟล์เป็นบรรทัดเดียว ตัวคั่นธงอนุญาตให้คุณผ่านสมการชนิด x + x ไปยัง bc

paste -s -d+ infile | bc

อีกทางเลือกหนึ่งเมื่อท่อจาก stdin

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

เวอร์ชั่นหนึ่งซับใน Python:

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

ฉันจะใส่คำเตือนครั้งใหญ่ในโซลูชันที่ได้รับการอนุมัติทั่วไป:

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

นั่นเป็นเพราะในรูปแบบนี้ awk ใช้การเป็นตัวแทนจำนวนเต็ม 32 บิตลงนาม: มันจะล้นสำหรับผลรวมที่เกิน 2147483647 (เช่น 2 ^ 31)

คำตอบทั่วไปเพิ่มเติม (สำหรับการรวมจำนวนเต็ม) จะเป็น:

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

ทุบตีธรรมดา:

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

โปรดทราบว่าควรแปลหมายเลขลบที่ขึ้นต้นด้วยเครื่องหมายลบdcเนื่องจากใช้_เครื่องหมายนำหน้าแทน-คำนำหน้า tr '-' '_' | dc -f- -e '...'ยกตัวอย่างเช่นผ่านทาง

แก้ไข: เนื่องจากคำตอบนี้ได้รับคะแนนเสียงมากมาย "เพื่อความสับสน" นี่คือคำอธิบายโดยละเอียด:

นิพจน์[+z1<r]srz1<rp ทำสิ่งต่อไปนี้ :

[   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

ในฐานะที่เป็นรหัสเทียม:

1. กำหนด "add_top_of_stack" เป็น:
   1. ลบค่าสูงสุดสองค่าออกจากสแต็กและเพิ่มผลลัพธ์กลับมา
   2. หากสแต็กมีสองค่าขึ้นไปให้รัน "add_top_of_stack" ซ้ำ
2. หากสแต็กมีสองค่าขึ้นไปให้เรียกใช้ "add_top_of_stack"
3. พิมพ์ผลลัพธ์ตอนนี้เหลือเพียงไอเท็มเดียวในสแต็ก

เพื่อให้เข้าใจถึงความเรียบง่ายและพลังของจริงdcๆ ได้นี่คือสคริปต์ Python ที่ใช้งานได้ซึ่งใช้คำสั่งบางคำสั่งdcและดำเนินการกับเวอร์ชัน 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()

ด้วยjq :

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

ทุบตีบริสุทธิ์และสั้น

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

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

สิบห้าเซ็นต์ของฉัน:

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

ตัวอย่าง:

$ 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

ฉันได้ทำเกณฑ์เปรียบเทียบอย่างรวดเร็วกับคำตอบที่มีอยู่แล้ว

• ใช้เครื่องมือมาตรฐานเท่านั้น (ขออภัยสำหรับสิ่งที่ชอบluaหรือrocket)
• เป็นหนึ่งในตอร์ปิโดจริง
• มีความสามารถในการเพิ่มจำนวนมาก (100 ล้าน) และ
• รวดเร็ว (ฉันไม่สนใจสิ่งที่ใช้เวลานานกว่าหนึ่งนาที)

ฉันมักจะเพิ่มจำนวน 1 ถึง 100 ล้านซึ่งสามารถทำได้บนเครื่องของฉันในเวลาน้อยกว่าหนึ่งนาทีสำหรับการแก้ปัญหาหลายอย่าง

นี่คือผลลัพธ์:

หลาม

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

วาง & Bc

หน่วยความจำในเครื่องของฉันหมด มันใช้งานได้ครึ่งขนาดของอินพุต (50 ล้านหมายเลข):

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

ดังนั้นฉันเดาว่าน่าจะใช้เวลาประมาณ 35 ถึง 100 ล้านตัว

Perl

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

ทับทิม

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

ค

เพื่อประโยชน์ในการเปรียบเทียบฉันได้รวบรวมเวอร์ชั่น C และทดสอบสิ่งนี้ด้วยเช่นกันเพื่อให้ทราบว่าโซลูชั่นที่ใช้เครื่องมือทำงานช้าลงเพียงใด

#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

ข้อสรุป

แน่นอนว่า C นั้นเร็วที่สุดใน 8 วินาที แต่โซลูชัน Pypy เพิ่มค่าใช้จ่ายเพียงเล็กน้อยประมาณ 30% ถึง 11วินาที แต่เพื่อความยุติธรรม Pypy นั้นไม่ได้มาตรฐานอย่างแน่นอน คนส่วนใหญ่มีการติดตั้ง CPython ซึ่งช้ากว่าอย่างมาก (22 ปี) ซึ่งเร็วเท่ากับโซลูชัน Awk ที่ได้รับความนิยม

วิธีที่เร็วที่สุดที่ใช้เครื่องมือมาตรฐานคือ Perl (15s)

ทุบตีธรรมดาหนึ่งซับ

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

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

วิธีการแก้ปัญหาทุบตีถ้าคุณต้องการที่จะทำให้คำสั่งนี้ (เช่นถ้าคุณจำเป็นต้องทำบ่อยครั้ง):

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

การใช้งาน:

addnums < /tmp/nums

ฉันคิดว่า AWK เป็นสิ่งที่คุณกำลังมองหา:

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

คุณสามารถใช้คำสั่งนี้โดยผ่านรายการตัวเลขผ่านอินพุตมาตรฐานหรือส่งไฟล์ที่มีตัวเลขเป็นพารามิเตอร์

งานต่อไปนี้ในทุบตี:

I=0

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

echo $I

คุณสามารถใช้ num-utils ได้ถึงแม้ว่ามันจะเกินความจำเป็นสำหรับสิ่งที่คุณต้องการ นี่เป็นชุดของโปรแกรมสำหรับจัดการตัวเลขในเชลล์และสามารถทำสิ่งที่ดีหลายอย่างรวมถึงการเพิ่มเข้าไปด้วย มันค่อนข้างล้าสมัย แต่ก็ยังใช้งานได้และมีประโยชน์หากคุณต้องการทำอะไรมากกว่านี้

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

ฉันรู้ว่านี่เป็นคำถามเก่า แต่ฉันชอบวิธีนี้พอที่จะแบ่งปัน

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

หากมีความสนใจฉันจะอธิบายวิธีการทำงาน

ทุบตีบริสุทธิ์และในหนึ่งซับ :-)

$ 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 -e "map {$x += $_} <> and print $x" < infile.txt

สำหรับคนรักทับทิม

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

ไม่สามารถหลีกเลี่ยงการส่งสิ่งนี้:

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

พบได้ที่นี่:
เปลือกยูนิกซ์ที่หรูหราที่สุดหนึ่งซับในรายการผลรวมของจำนวนความแม่นยำโดยพลการ?

และนี่คือข้อดีพิเศษของ awk, bc และผองเพื่อน:

• มันไม่ได้ขึ้นอยู่กับการบัฟเฟอร์ดังนั้นจึงไม่ทำให้หายใจไม่ออกด้วยอินพุตที่ใหญ่มาก
• มันบอกเป็นนัยไม่มีความแม่นยำโดยเฉพาะหรือขนาดจำนวนเต็มสำหรับเรื่องที่ จำกัด
• ไม่จำเป็นต้องใช้รหัสที่แตกต่างกันหากจำเป็นต้องเพิ่มหมายเลขจุดลอย

ใช้GNU datamash util :

seq 10 | datamash sum 1

เอาท์พุท:

55

หากข้อมูลอินพุตไม่สม่ำเสมอด้วยช่องว่างและแท็บในสถานที่แปลก ๆ อาจทำให้เกิดความสับสนdatamashจากนั้นใช้-Wสวิตช์:

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

... หรือใช้trเพื่อล้างช่องว่าง:

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

รุ่นของฉัน:

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

คุณสามารถทำได้ในไพ ธ อนถ้าคุณรู้สึกสะดวกสบาย:

ไม่ได้ทดสอบพิมพ์เพียง:

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

เซบาสเตียนชี้ให้เห็นบทภาพยนตร์เรื่องหนึ่ง:

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

หรือคุณสามารถพิมพ์ตัวเลขในบรรทัดคำสั่ง:

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

อย่างไรก็ตามไฟล์นี้จะลบไฟล์ดังนั้นจึงไม่ควรใช้กับไฟล์ขนาดใหญ่ ดูคำตอบ j_random_hackerที่หลีกเลี่ยงการ slurping

ข้อมูลต่อไปนี้ควรใช้งานได้ (สมมติว่าหมายเลขของคุณเป็นฟิลด์ที่สองในแต่ละบรรทัด)

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

หนึ่งซับในแร็กเกต:

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

C (ไม่ง่าย)

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)

ขออภัยล่วงหน้าสำหรับการอ่าน backticks ("` ") แต่การทำงานเหล่านี้ในเชลล์นอกเหนือจาก bash และทำให้สามารถวางได้มากกว่า หากคุณใช้เชลล์ที่ยอมรับรูปแบบ $ (คำสั่ง ... ) สามารถอ่านได้มากขึ้น (และสามารถ debuggable) ได้มากกว่าคำสั่ง `` ... 'ดังนั้นอย่าลังเลที่จะแก้ไขสำหรับสติของคุณ

ฉันมีฟังก์ชั่นที่เรียบง่ายใน bashrc ของฉันที่จะใช้ awk เพื่อคำนวณจำนวนรายการทางคณิตศาสตร์อย่างง่าย

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

สิ่งนี้จะทำ +, -, *, /, ^,%, sqrt, sin, cos, วงเล็บ .... (และอื่น ๆ ขึ้นอยู่กับรุ่นของ awk ของคุณ) ... คุณยังสามารถเพลิดเพลินกับ printf และฟอร์แมตจุดลอยตัว เอาท์พุท แต่นี่คือทั้งหมดที่ฉันต้องการตามปกติ

สำหรับคำถามนี้โดยเฉพาะฉันจะทำเช่นนี้สำหรับแต่ละบรรทัด:

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

ดังนั้นบล็อคโค้ดเพื่อรวมแต่ละบรรทัดจะมีลักษณะดังนี้:

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

นั่นคือถ้าคุณต้องการที่จะรวมพวกเขาทีละบรรทัด อย่างไรก็ตามสำหรับจำนวนทุกจำนวนใน datafile

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

btw ถ้าฉันต้องการทำบางสิ่งบางอย่างอย่างรวดเร็วบนเดสก์ท็อปฉันใช้สิ่งนี้:

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