Perintah Shell untuk menjumlahkan bilangan bulat, satu per baris?

Saya mencari perintah yang akan menerima (sebagai input) beberapa baris teks, setiap baris berisi bilangan bulat tunggal, dan menampilkan jumlah bilangan bulat ini.

Sebagai sedikit latar belakang, saya memiliki file log yang mencakup pengukuran waktu. Melalui grepping untuk baris yang relevan dan sedikit sedmemformat ulang saya bisa daftar semua timing dalam file itu. Saya ingin menghitung totalnya. Saya dapat menyalurkan output antara ini ke perintah apa saja untuk melakukan penjumlahan akhir. Saya selalu menggunakan exprdi masa lalu, tetapi kecuali itu berjalan dalam mode RPN saya tidak berpikir itu akan mengatasi ini (dan bahkan kemudian itu akan sulit).

Bagaimana saya bisa mendapatkan penjumlahan bilangan bulat?

Sedikit canggung harus melakukannya?

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

Catatan: beberapa versi awk memiliki beberapa perilaku aneh jika Anda akan menambahkan sesuatu yang melebihi 2 ^ 31 (2147483647). Lihat komentar untuk latar belakang lebih lanjut. Satu saran adalah menggunakan printfdaripada print:

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

Rekatkan biasanya menggabungkan baris beberapa file, tetapi juga dapat digunakan untuk mengubah setiap baris file menjadi satu baris. Bendera pembatas memungkinkan Anda untuk melewatkan persamaan tipe x + x ke bc.

paste -s -d+ infile | bc

Atau, saat pemipaan dari stdin,

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

Versi satu-baris dalam Python:

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

Saya akan menaruh PERINGATAN besar pada solusi yang disetujui secara umum:

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

itu karena dalam bentuk ini awk menggunakan representasi integer bertanda 32 bit: ia akan melimpah untuk jumlah yang melebihi 2147483647 (yaitu, 2 ^ 31).

Jawaban yang lebih umum (untuk menjumlahkan bilangan bulat) adalah:

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

Pesta polos:

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

Perhatikan bahwa angka negatif yang diawali dengan tanda minus harus diterjemahkan untuk dc, karena menggunakan _awalan daripada -awalan untuk itu. Misalnya melalui tr '-' '_' | dc -f- -e '...'.

Sunting: Karena jawaban ini mendapatkan begitu banyak suara "untuk ketidakjelasan", berikut adalah penjelasan terperinci:

Ekspresi [+z1<r]srz1<rp melakukan hal berikut :

[   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

Sebagai pseudo-code:

1. Tentukan "add_top_of_stack" sebagai:
   1. Hapus dua nilai teratas dari tumpukan dan tambahkan hasilnya kembali
   2. Jika tumpukan memiliki dua atau lebih nilai, jalankan "add_top_of_stack" secara rekursif
2. Jika tumpukan memiliki dua atau lebih nilai, jalankan "add_top_of_stack"
3. Cetak hasilnya, sekarang satu-satunya item yang tersisa di tumpukan

Untuk benar-benar memahami kesederhanaan dan kekuatan dc, berikut ini adalah skrip Python yang berfungsi yang mengimplementasikan beberapa perintah dari dcdan mengeksekusi versi Python dari perintah di atas:

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

Dengan jq :

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

Pesta murni dan pendek.

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

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

Lima belas sen saya:

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

Contoh:

$ 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

Saya sudah melakukan patokan cepat pada jawaban yang ada

• hanya menggunakan alat standar (maaf untuk hal-hal seperti luaatau rocket),
• adalah one-liners nyata,
• mampu menambahkan angka dalam jumlah besar (100 juta), dan
• cepat (saya mengabaikan yang membutuhkan waktu lebih dari satu menit).

Saya selalu menambahkan angka 1 hingga 100 juta yang dapat dilakukan pada komputer saya dalam waktu kurang dari satu menit untuk beberapa solusi.

Inilah hasilnya:

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

Tempel & Bc

Ini kehabisan memori pada mesin saya. Ini berfungsi untuk setengah ukuran input (angka 50 juta):

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

Jadi saya kira itu akan mengambil ~ 35 untuk 100 juta angka.

Perl

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

Rubi

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

C

Hanya untuk perbandingan, saya menyusun versi C dan menguji ini juga, hanya untuk mengetahui seberapa jauh lebih lambat solusi berbasis alat.

#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

Kesimpulan

C tentu saja tercepat dengan 8s, tetapi solusi Pypy hanya menambahkan sedikit overhead sekitar 30% menjadi 11s . Tapi, agar adil, Pypy tidak sepenuhnya standar. Kebanyakan orang hanya menginstal CPython yang jauh lebih lambat (22-an), persis secepat solusi populer Awk.

Solusi tercepat berdasarkan pada alat standar adalah Perl (15s).

Bash polos satu liner

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

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

Solusi BASH, jika Anda ingin menjadikan ini sebagai perintah (mis. Jika Anda harus sering melakukan ini):

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

Kemudian penggunaan:

addnums < /tmp/nums

Saya pikir AWK adalah apa yang Anda cari:

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

Anda dapat menggunakan perintah ini baik dengan meneruskan daftar angka melalui input standar atau dengan mengirimkan file yang berisi angka sebagai parameter.

Berikut ini berfungsi di bash:

I=0

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

echo $I

Anda dapat menggunakan num-utils, meskipun mungkin terlalu banyak untuk apa yang Anda butuhkan. Ini adalah sekumpulan program untuk memanipulasi angka dalam shell, dan dapat melakukan beberapa hal bagus, termasuk tentu saja, menambahkannya. Agak ketinggalan zaman, tetapi masih berfungsi dan dapat berguna jika Anda perlu melakukan sesuatu yang lebih.

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

Saya menyadari ini adalah pertanyaan lama, tetapi saya cukup menyukai solusi ini untuk membagikannya.

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

Jika ada minat, saya akan menjelaskan cara kerjanya.

Bash murni dan dalam satu baris :-)

$ 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

Alternatif Perl murni, cukup mudah dibaca, tidak ada paket atau opsi yang diperlukan:

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

Untuk Pecinta Ruby

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

Tidak dapat menghindari mengirimkan ini:

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

Ditemukan di sini:
Kebanyakan unix shell satu-liner yang elegan untuk menjumlahkan daftar jumlah presisi yang sewenang-wenang?

Dan berikut ini adalah kelebihan khusus dari awk, bc dan teman-teman:

• itu tidak tergantung pada buffering dan karenanya tidak tersumbat dengan input yang sangat besar
• itu menyiratkan tidak ada presisi tertentu - atau ukuran bilangan bulat untuk hal itu - batas
• tidak perlu kode yang berbeda, jika nomor floating point perlu ditambahkan

Menggunakan utilisasi GNU datamash :

seq 10 | datamash sum 1

Keluaran:

55

Jika input data tidak teratur, dengan spasi dan tab di tempat ganjil, ini dapat membingungkan datamash, maka gunakan -Wsakelar:

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

... atau gunakan truntuk membersihkan spasi:

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

Versi saya:

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

Anda bisa melakukannya dengan python, jika Anda merasa nyaman:

Tidak diuji, cukup diketik:

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

Sebastian menunjukkan naskah satu liner:

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

Atau, Anda bisa mengetikkan angka di baris perintah:

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

Namun, yang satu ini menyeruput file tersebut sehingga itu bukan ide yang baik untuk digunakan pada file besar. Lihat j_random_hacker jawaban yang menghindari menghirup.

Berikut ini harus berfungsi (dengan asumsi nomor Anda adalah bidang kedua pada setiap baris).

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

One-liner di Racket:

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

C (tidak disederhanakan)

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)

Permintaan maaf sebelumnya untuk keterbacaan backticks ("` "), tetapi ini bekerja dalam cangkang selain bash dan karenanya lebih mudah ditempel. Jika Anda menggunakan shell yang menerimanya, format $ (command ...) jauh lebih mudah dibaca (dan dengan demikian dapat ditiadakan) daripada `command ...` jadi jangan ragu untuk memodifikasi kewarasan Anda.

Saya memiliki fungsi sederhana di bashrc saya yang akan menggunakan awk untuk menghitung sejumlah item matematika sederhana

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

Ini akan melakukan +, -, *, /, ^,%, sqrt, sin, cos, kurung .... (dan lebih banyak tergantung pada versi awk Anda) ... Anda bahkan dapat menikmati printf dan memformat floating point output, tapi ini semua biasanya saya butuhkan

untuk pertanyaan khusus ini, saya cukup melakukan ini untuk setiap baris:

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

jadi blok kode untuk menjumlahkan setiap baris akan terlihat seperti ini:

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

Itu jika Anda hanya ingin menjumlahkannya baris demi baris. Namun untuk total setiap angka dalam datafile

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

btw jika saya perlu melakukan sesuatu dengan cepat di desktop, saya menggunakan ini:

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