Her satıra bir tane olmak üzere tamsayıları toplamak için Shell komutu?

Ben (giriş olarak) metin, her satır tek bir tamsayı içeren ve bu tamsayıların toplamı çıkış kabul edecek bir komut arıyorum.

Biraz arka plan olarak, zamanlama ölçümleri içeren bir günlük dosyası var. İlgili satırlar için selamlama ve biraz sedyeniden biçimlendirme yoluyla bu dosyadaki tüm zamanlamaları listeleyebilirim. Toplamı bulmak istiyorum. Nihai toplamı yapmak için bu ara çıkışı herhangi bir komuta bağlayabilirim. Her zaman exprgeçmişte kullandım , ancak RPN modunda çalışmadığı sürece bununla başa çıkacağını düşünmüyorum (ve o zaman bile zor olurdu).

Tamsayıların toplamını nasıl alabilirim?

Biraz awk yapmalı mı?

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

Not: 2 ^ 31 (2147483647) değerini aşan bir şey ekleyecekseniz awk'nin bazı sürümlerinde bazı garip davranışlar vardır. Daha fazla arka plan için yorumlara bakın. Bir öneri aşağıdakilerden printfziyade kullanmaktır print:

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

Yapıştır genellikle birden çok dosyanın satırlarını birleştirir, ancak bir dosyanın tek tek satırlarını tek bir satıra dönüştürmek için de kullanılabilir. Sınırlayıcı bayrağı, bc'ye x + x tipi bir denklem geçirmenize izin verir.

paste -s -d+ infile | bc

Alternatif olarak, stdin'den borulama yaparken,

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

Python'daki tek katmanlı sürüm:

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

Yaygın olarak onaylanan çözüme büyük bir UYARI koyarım:

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

çünkü bu formda awk 32 bit işaretli bir tamsayı gösterimi kullanır: 2147483647'yi (yani, 2 ^ 31) aşan toplamlar için taşacaktır.

Daha genel bir cevap (tamsayıları toplamak için):

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

Düz 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'

Eksi işaretiyle önek eklenmiş negatif sayıların dc, _önek yerine -önek kullandığından, çevrilmesi gerektiğini unutmayın . Örneğin, üzerinden tr '-' '_' | dc -f- -e '...'.

Edit: Bu cevap "müstehcenlik için" çok oy aldığından, İşte ayrıntılı bir açıklama:

İfade [+z1<r]srz1<rp aşağıdakileri yapar :

[   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

Sahte kod olarak:

1. "Add_top_of_stack" öğesini şu şekilde tanımlayın:
   1. Yığındaki en yüksek iki değeri kaldırın ve sonucu geri ekleyin
   2. Yığının iki veya daha fazla değeri varsa, "add_top_of_stack" komutunu tekrar tekrar çalıştırın
2. Yığının iki veya daha fazla değeri varsa, "add_top_of_stack" komutunu çalıştırın
3. Sonucu yazdırın, şimdi yığınta kalan tek öğe

Basitliğini ve gücünü gerçekten anlamak için , yukarıdaki dckomutların bazılarını uygulayan dcve yukarıdaki komutun Python sürümünü çalıştıran çalışan bir Python betiği :

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

İle JQ :

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

Saf ve kısa bash.

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

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

On beş sentim:

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

Misal:

$ 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

Mevcut cevaplar hakkında kısa bir değerlendirme yaptım.

• sadece standart araçlar kullanın ( luaveya gibi şeyler için özür dilerim rocket),
• gerçek tek gömlekli,
• çok sayıda (100 milyon) rakam ekleyebilir ve
• hızlı (bir dakikadan uzun sürenleri görmezden geldim).

Her zaman birkaç ila birkaç dakika içinde makinemde yapılabilen 1 ila 100 milyon arasındaki sayıları ekledim.

Sonuçlar burada:

piton

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

Yapıştır & Bc

Bu makinemde bellek kalmadı. Girdinin yarısı kadar çalıştı (50 milyon sayı):

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

Bu yüzden sanırım 100 milyon sayı için ~ 35s alacaktı.

Perl

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

Yakut

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

C

Sadece karşılaştırma için, C sürümünü derledim ve bunu da test ettim, sadece araç tabanlı çözümlerin ne kadar yavaş olduğu hakkında bir fikrim var.

#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

Sonuç

C elbette 8 saniye ile en hızlı, ancak Pypy çözümü sadece yaklaşık% 30 ila 11 saniye arasında çok az ek yük getiriyor . Ancak, adil olmak gerekirse, Pypy tam olarak standart değildir. Çoğu insan sadece CPython yüklüdür ve bu da popüler Awk çözümü kadar hızlıdır.

Standart araçlara dayalı en hızlı çözüm Perl'dir (15s).

Düz bash bir astar

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

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

BASH çözümü, bunu bir komut yapmak istiyorsanız (örneğin, bunu sık sık yapmanız gerekiyorsa):

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

Sonra kullanım:

addnums < /tmp/nums

AWK aradığın şey olduğunu düşünüyorum:

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

Bu komutu, numaralar listesini standart girdiden geçirerek veya sayıları içeren dosyayı parametre olarak geçirerek kullanabilirsiniz.

Aşağıdaki bash çalışır:

I=0

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

echo $I

Num-utils kullanabilirsiniz, ancak ihtiyacınız olan şey için aşırı olabilir. Bu, kabuktaki sayıları işlemek için bir dizi programdır ve elbette onları toplamak da dahil olmak üzere birkaç şık şey yapabilir. Biraz güncel değil, ama yine de çalışıyorlar ve daha fazla bir şey yapmanız gerekiyorsa yararlı olabilirler.

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

Bunun eski bir soru olduğunun farkındayım, ancak bu çözümü paylaşacak kadar seviyorum.

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

İlgi varsa, nasıl çalıştığını açıklayacağım.

Saf bash ve tek astarlı :-)

$ 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 saf Perl, oldukça okunabilir, paket veya seçenek gerekmez:

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

Ruby Lovers için

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

Bunu göndermekten kaçınamazsınız:

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

Burada bulunur:
En hassas unix kabuk keyfi bir dizi sayı listesini toplamak için?

Ve işte awk, bc ve arkadaşlara göre özel avantajları:

• tamponlamaya bağlı değildir ve bu nedenle gerçekten büyük girdilerle boğulmaz
• belirli bir hassasiyet veya bu konu için tamsayı boyutu anlamına gelmez
• kayan nokta numaralarının eklenmesi gerekiyorsa, farklı koda gerek yoktur

Kullanılması GNU datamash util :

seq 10 | datamash sum 1

Çıktı:

55

Giriş verileri düzensizse, garip yerlerde boşluklar ve sekmeler varsa, bu kafa karıştırıcı olabilir datamash, daha sonra -Wanahtarı kullanın :

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

... veya trboşlukları temizlemek için kullanın :

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

Benim versiyonum:

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

Eğer rahat hissediyorsanız python ile yapabilirsiniz:

Test edilmedi, sadece yazdı:

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

Sebastian tek satırlık bir senaryoya dikkat çekti:

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

$ kedi n
2
4
2
7
8
9

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

Veya komut satırındaki sayıları yazabilirsiniz:

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

Ancak, bu dosyada büyük dosyalar üzerinde kullanmak iyi bir fikir değil, bu yüzden slurps. Kaymayı önleyen j_random_hacker'ın cevabına bakınız .

Aşağıdakiler işe yaramalıdır (numaranızın her satırdaki ikinci alan olduğu varsayılarak).

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

Rakette Tek Astar:

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

C (basitleştirilmemiş)

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)

İğnelerin okunabilirliği için şimdiden özür dileriz ("` "), ancak bunlar bash dışındaki kabuklarda çalışır ve bu nedenle daha uzatılabilir. Kabul eden bir kabuk kullanırsanız, $ (command ...) formatı `command ... '' dan çok daha okunabilir (ve dolayısıyla hata ayıklanabilir) olur, bu nedenle akıl sağlığınız için değişiklik yapmaktan çekinmeyin.

Benim bashrc basit bir matematik öğeleri hesaplamak için awk kullanacak basit bir işlevi var

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

Bu +, -, *, /, ^,%, sqrt, sin, cos, parantez .... (ve daha fazlası awk sürümünüze bağlı olarak) yapacaktır ... printf ve format kayan nokta ile bile süsleyebilirsiniz çıktı, ama normalde tüm ihtiyacım olan bu

bu özel soru için, her satır için bunu yapardım:

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

böylece her satırı toplamak için kod bloğu şöyle görünecektir:

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

Onları sadece satır satır toplamak istiyorsanız. Ancak veri dosyasındaki her sayının toplamı için

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

btw masaüstünde hızlı bir şey yapmak gerekirse, ben bunu kullanın:

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