मैं किसी फ़ाइल में सभी संख्याओं को कैसे जोड़ सकता हूँ?

Question

मेरे पास एक फ़ाइल है जिसमें कई हज़ार नंबर हैं, जिनमें से प्रत्येक की अपनी लाइन है:

34
42
11
6
2
99
...

मैं एक स्क्रिप्ट लिखने के लिए देख रहा हूं, जो फाइल में सभी नंबरों का योग प्रिंट करेगी। मुझे एक समाधान मिल गया है, लेकिन यह बहुत कुशल नहीं है। (इसे चलाने में कई मिनट लगते हैं।) मैं एक अधिक कुशल समाधान ढूंढ रहा हूं। कोई सुझाव?

Comments

आपका धीमा समाधान क्या था? शायद हम आपको यह पता लगाने में मदद कर सकते हैं कि इसके बारे में क्या धीमा था। :)

— ब्रायन डी फ़ोय

@ ब्रायन डी फ़ोय, मैं इसे पोस्ट करने के लिए बहुत शर्मिंदा हूं। मुझे पता है कि यह धीमा क्यों है। यह इसलिए है क्योंकि मैं शीर्ष नंबर प्राप्त करने के लिए "कैट फाइलन | हेड-एन 1" कहता हूं, इसे एक चलने वाले कुल में जोड़ देता हूं, और अगले पुनरावृत्ति के लिए शीर्ष लाइन को हटाने के लिए "कैट फाइलनेम | टेल ..." कॉल करता हूं ... I प्रोग्रामिंग के बारे में जानने के लिए बहुत कुछ है !!!

— मार्क रॉबर्ट्स

यह ... बहुत व्यवस्थित है। बहुत स्पष्ट और सीधे आगे, और मैं इसे सभी के लिए प्यार करता हूं कि यह एक भयानक घृणा है। निर्मित, मुझे लगता है, उन उपकरणों में से, जिन्हें आप जानते थे कि आपने कब शुरू किया है, ठीक है?

— dmckee --- पूर्व-संचालक बिल्ली का बच्चा

पूर्ण डुप्लिकेट: stackoverflow.com/questions/450799/…

— कोडहोल

@MarkRoberts इसे काम करने में आपको बहुत समय लग गया होगा। यह एक बहुत क्लीवर समस्या को सुलझाने की तकनीक है, और ओह बहुत गलत है। यह ओवर थिंक का क्लासिक केस लगता है। ग्लेन जैकमैन के कई समाधान शेल स्क्रिप्टिंग समाधान (और दो शुद्ध शेल हैं जो चीजों का उपयोग नहीं करते हैं ) awkऔर bc। इन सभी ने 10 सेकंड से भी कम समय में एक लाख की संख्या जोड़ ली। उन पर एक नज़र डालें और देखें कि यह शुद्ध शेल में कैसे किया जा सकता है।

— डेविड डब्ल्यू।

Answer 1

पर्ल वन-लाइनर के लिए, यह मूल रूप से आयान होउरीह के जवाबawk में समाधान के समान है :

 % perl -nle '$sum += $_ } END { print $sum'

यदि आप उत्सुक हैं कि पर्ल वन-लाइनर्स क्या करते हैं, तो आप उन्हें उलट सकते हैं:

 %  perl -MO=Deparse -nle '$sum += $_ } END { print $sum'

परिणाम कार्यक्रम का एक अधिक वर्बोज़ संस्करण है, इस रूप में कि कोई भी कभी भी अपने दम पर नहीं लिखेगा:

BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined($_ = <ARGV>)) {
    chomp $_;
    $sum += $_;
}
sub END {
    print $sum;
}
-e syntax OK

बस गिगल्स के लिए, मैंने 1,000,000 संख्याओं वाली फ़ाइल के साथ यह कोशिश की (रेंज 0 - 9,999 में)। मेरे मैक प्रो पर, यह लगभग तुरंत लौटता है। यह बहुत बुरा है, क्योंकि मैं उम्मीद कर रहा था कि इसका उपयोग mmapवास्तव में तेज़ होगा, लेकिन यह सिर्फ एक ही समय है:

use 5.010;
use File::Map qw(map_file);

map_file my $map, $ARGV[0];

$sum += $1 while $map =~ m/(\d+)/g;

say $sum;

Comments

वाह, यह एक गहरी समझ दिखाता है कि कोड क्या-क्या वास्तव में स्ट्रिंग के चारों ओर लपेटता है जो आप इसे देते हैं। मेरा प्रारंभिक विचार यह था कि आप नशे में रहते हुए पोस्ट नहीं करना चाहिए, लेकिन फिर मैंने देखा कि आप कौन थे और अपने कुछ अन्य पर्ल जवाबों को याद किया :-)

— paxdiablo

-n -p केवल -e के तर्क के चारों ओर वर्ण डालते हैं, इसलिए आप उन वर्णों का उपयोग कर सकते हैं जो आप चाहते हैं। हमारे पास बहुत सारे एक-लाइनर हैं जो प्रभावी पर्ल प्रोग्रामिंग (जो अलमारियों को मारने के बारे में हैं) में उसके साथ दिलचस्प चीजें करते हैं ।

— ब्रायन डी फॉय

अच्छा, इन गैर-मिलान घुंघराले ब्रेसिज़ के बारे में क्या हैं?

— फ्रैंक

-n while { }आपके प्रोग्राम के चारों ओर लूप जोड़ता है । अगर आप } ... {अंदर डालते हैं, तो आपके पास है while { } ... { }। बुराई? थोड़ा।

— jrockway

-MO=Deparseविकल्प को उजागर करने के लिए बड़ा बोनस ! हालांकि एक अलग विषय पर भी।

— शंकु

Answer 2

आप awk का उपयोग कर सकते हैं:

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

Comments

कार्यक्रम पार हो गया: अधिकतम क्षेत्र आकार: 32767

— लेफ

-F '\t'विकल्प के साथ यदि आपके खेतों में स्थान हैं और टैब द्वारा अलग किए गए हैं।

— एथन फुरमान

कृपया इसे सर्वश्रेष्ठ उत्तर के रूप में चिह्नित करें। यह भी काम करता है यदि आप प्रत्येक पंक्ति में पहला मान सम्‍मिलित करना चाहते हैं, तो TSV (टैब-अलग मान) फ़ाइल के अंदर।

— एंड्रिया

Answer 3

इस प्रकार समाधान का कोई भी उपयोग नहीं करता है paste। यहां एक है:

paste -sd+ filename | bc

एक उदाहरण के रूप में, गणना करें जहां 1 <= n <= 100000:

$ seq 100000 | paste -sd+ | bc -l
5000050000

(उत्सुक के लिए, seq nसे संख्या का एक अनुक्रम मुद्रित होगा 1करने के लिए nदिए गए एक सकारात्मक संख्या n।)

Comments

बहुत अच्छा! और याद रखना आसान है

— ब्रेंडन मैगुएर

seq 100000 | paste -sd+ - | bc -lमैक ओएस एक्स बैश शेल पर। और यह अब तक का सबसे मधुर और अनोखा समाधान है!

— सिमो ए।

@SimoA। मैं वोट है कि हम क्योंकि कामुक समाधान के लिए unixest के स्थान पर unixiest शब्द का प्रयोग हमेशा unixiest है;)

— कॉनर

Answer 4

बस मनोरंजन के लिए, आइए इसे बेंचमार्क करें:

$ for ((i=0; i<1000000; i++)) ; do echo $RANDOM; done > random_numbers

$ time perl -nle '$sum += $_ } END { print $sum' random_numbers
16379866392

real    0m0.226s
user    0m0.219s
sys     0m0.002s

$ time awk '{ sum += $1 } END { print sum }' random_numbers
16379866392

real    0m0.311s
user    0m0.304s
sys     0m0.005s

$ time { { tr "\n" + < random_numbers ; echo 0; } | bc; }
16379866392

real    0m0.445s
user    0m0.438s
sys     0m0.024s

$ time { s=0;while read l; do s=$((s+$l));done<random_numbers;echo $s; }
16379866392

real    0m9.309s
user    0m8.404s
sys     0m0.887s

$ time { s=0;while read l; do ((s+=l));done<random_numbers;echo $s; }
16379866392

real    0m7.191s
user    0m6.402s
sys     0m0.776s

$ time { sed ':a;N;s/\n/+/;ta' random_numbers|bc; }
^C

real    4m53.413s
user    4m52.584s
sys 0m0.052s

मैंने 5 मिनट के बाद सेड रन को रोक दिया

---

मैं डाइविंग कर रहा हूं lua, और यह शीघ्र है:

$ time lua -e 'sum=0; for line in io.lines() do sum=sum+line end; print(sum)' < random_numbers
16388542582.0

real    0m0.362s
user    0m0.313s
sys     0m0.063s

और जब मैं इसे अपडेट कर रहा हूं, रूबी:

$ time ruby -e 'sum = 0; File.foreach(ARGV.shift) {|line| sum+=line.to_i}; puts sum' random_numbers
16388542582

real    0m0.378s
user    0m0.297s
sys     0m0.078s

---

एड एड मॉर्टन की सलाह: उपयोग करना $1

$ time awk '{ sum += $1 } END { print sum }' random_numbers
16388542582

real    0m0.421s
user    0m0.359s
sys     0m0.063s

बनाम का उपयोग कर $0

$ time awk '{ sum += $0 } END { print sum }' random_numbers
16388542582

real    0m0.302s
user    0m0.234s
sys     0m0.063s

Comments

+1: समाधानों के एक समूह के साथ आने के लिए, और उन्हें बेंचमार्क करना।

— डेविड डब्ल्यू।

टाइम कैट रैंडम_न्यूज | पेस्ट -sd + | bc -l real 0m0.317s उपयोगकर्ता 0m0.310s sys 0m0.013s

— wiener

यह trसमाधान के समान होना चाहिए ।

— ग्लेन जैकमैन

यदि आप किसी क्षेत्र विशेष रूप से स्क्रिप्ट में उल्लेख किया गया है, लेकिन अन्यथा नहीं किया जाता है, तो आपके awk स्क्रिप्ट को थोड़ी तेज़ी से निष्पादित करना चाहिए $0, $1क्योंकि आप इसके बजाय उपयोग करते हैं, क्योंकि awk फ़ील्ड विभाजन (जो स्पष्ट रूप से समय लगता है) करता है।

— एड मॉर्टन

Answer 5

एक अन्य विकल्प का उपयोग करना है jq:

$ seq 10|jq -s add
55

-s( --slurp) इनपुट लाइनों को एक सरणी में पढ़ता है।

Comments

यह इस तरह के त्वरित कार्यों के लिए एक भयानक उपकरण है, लगभग इसके बारे में भूल गया। धन्यवाद

— जॉन

Answer 6

यह सीधे बैश है:

sum=0
while read -r line
do
    (( sum += line ))
done < file
echo $sum

Comments

और यह शायद सबसे धीमे समाधानों में से एक है और इसलिए बड़ी संख्या के लिए उपयुक्त नहीं है।

— डेविड

Answer 7

यहाँ एक और एक लाइनर है

( echo 0 ; sed 's/$/ +/' foo ; echo p ) | dc

यह मानता है कि संख्या पूर्णांक हैं। यदि आपको दशमलव की आवश्यकता है, तो प्रयास करें

( echo 0 2k ; sed 's/$/ +/' foo ; echo p ) | dc

आवश्यक दशमलव की संख्या में 2 समायोजित करें।

Answer 8

मैं इस तरह के कार्यों के लिए GNU डेटामैश का उपयोग करना पसंद करता हूं क्योंकि यह पर्ल या ऑक की तुलना में अधिक रसीला और सुपाच्य है। उदाहरण के लिए

datamash sum 1 < myfile

जहाँ 1 डेटा के पहले कॉलम को दर्शाता है।

Comments

यह एक मानक घटक प्रतीत नहीं होता है क्योंकि मैं इसे अपने उबंटू स्थापना में नहीं देखता हूं। हालाँकि इसे बेंचमार्क के रूप में देखना चाहेंगे।

— स्टीवन आसानी से इस्तेमाल होने वाली

Answer 9

$ perl -MList::Util=sum -le 'print sum <>' nums.txt

Answer 10

मैं इसके लिए R का उपयोग करना पसंद करता हूं:

$ R -e 'sum(scan("filename"))'

Comments

मैं अन्य अनुप्रयोगों के लिए R का प्रशंसक हूं लेकिन इस तरह से प्रदर्शन के लिए यह अच्छा नहीं है। फ़ाइल I / O एक प्रमुख मुद्दा है। मैंने एक स्क्रिप्ट पर पासिंग आर्ग्स का परीक्षण किया है जिसे वरूम पैकेज का उपयोग करके स्पेड किया जा सकता है। जब मैंने उसी सर्वर पर कुछ अन्य स्क्रिप्ट को बेंचमार्क किया तो मैं अधिक विवरण पोस्ट करूँगा।

— टॉम केली

Answer 11

cat nums | perl -ne '$sum += $_ } { print $sum'

('डीएआर' के बिना ब्रायन डी फॉय का जवाब)

Comments

मुझे यह पसंद है, लेकिन क्या आप घुंघराले कोष्ठक की व्याख्या कर सकते हैं? यह {} के बिना और इसके विपरीत देखने के लिए अजीब है।

— गोलाबारी

@drumfire ऊपर @brian d foy का उत्तर perl -MO=Deparseदेखता है कि कैसे पर्ल कार्यक्रम को देखता है। या perlrun के लिए डॉक्स: perldoc.perl.org/perlrun.html (-n के लिए खोज)। पर्ल आपके कोड को {} के साथ लपेटता है यदि आप -n का उपयोग करते हैं तो यह एक पूर्ण कार्यक्रम बन जाता है।

— 25

Answer 12

अधिक रसीला:

# Ruby
ruby -e 'puts open("random_numbers").map(&:to_i).reduce(:+)'

# Python
python -c 'print(sum(int(l) for l in open("random_numbers")))'

Comments

मेरे सिस्टम पर दो बार (320 बनाम 640 एमएस) के रूप में फ़्लोट करने के लिए बदलने के लिए लगता है। time python -c "print(sum([float(s) for s in open('random_numbers','r')]))"

— user12719

Answer 13

पर्ल 6

say sum lines

~$ perl6 -e '.say for 0..1000000' > test.in

~$ perl6 -e 'say sum lines' < test.in
500000500000

Answer 14

बस मनोरंजन के लिए, इसे पीडीएल , पर्ल के सरणी गणित इंजन के साथ करने दें!

perl -MPDL -E 'say rcols(shift)->sum' datafile

rcolsएक मैट्रिक्स में कॉलम पढ़ता है (इस मामले में 1D) और sum(आश्चर्य) मैट्रिक्स के सभी तत्व को बताता है।

Comments

@INC में PDL.pm को कैसे ठीक कर सकते हैं (आपको PDL मॉड्यूल को स्थापित करने की आवश्यकता हो सकती है) (@INC में शामिल हैं: / etc / perl /usr/local/lib/x86_64-linux-gnu/nl/5.22.1? )) मस्ती के लिए =)

— फोरट्रान

आपको पहले पीडीएल स्थापित करना होगा, यह एक पर्ल देशी मॉड्यूल नहीं है।

— जोएल बर्जर

Answer 15

यहां एक जनरेटर अभिव्यक्ति के साथ अजगर का उपयोग कर एक समाधान है। मेरे पुराने cruddy लैपटॉप पर एक लाख की संख्या के साथ परीक्षण किया गया।

time python -c "import sys; print sum((float(l) for l in sys.stdin))" < file

real    0m0.619s
user    0m0.512s
sys     0m0.028s

Comments

नामांकित फ़ंक्शन के साथ एक सरल सूची समझ के लिए एक अच्छा उपयोग-मामला है map():map(float, sys.stdin)

— sevko

Answer 16

मैं बस पास नहीं कर सका ... यहाँ मेरा हास्केल वन-लाइनर है। यह वास्तव में काफी पठनीय है:

sum <$> (read <$>) <$> lines <$> getContents

दुर्भाग्य से ghci -e, इसे चलाने के लिए कोई नहीं है, इसलिए इसे मुख्य कार्य, प्रिंट और संकलन की आवश्यकता है।

main = (sum <$> (read <$>) <$> lines <$> getContents) >>= print

स्पष्ट करने के लिए, हम पूरे इनपुट (पढ़ getContents), द्वारा इसे विभाजित lines, readसंख्या और के रूप में sum। <$>है fmapऑपरेटर - हम हमेशा की तरह समारोह आवेदन के बजाय इसका उपयोग क्योंकि यकीन है कि यह सब आईओ में होता है। readअतिरिक्त की जरूरत है fmap, क्योंकि यह सूची में भी है।

$ ghc sum.hs
[1 of 1] Compiling Main             ( sum.hs, sum.o )
Linking sum ...
$ ./sum 
1
2
4
^D
7

यहां तैरने के साथ काम करने के लिए एक अजीब उन्नयन है:

main = ((0.0 + ) <$> sum <$> (read <$>) <$> lines <$> getContents) >>= print

$ ./sum 
1.3
2.1
4.2
^D
7.6000000000000005

Answer 17

sed ':a;N;s/\n/+/;ta' file|bc

Answer 18

रनिंग स्क्रिप्ट्स

मैंने फ़ाइल नाम के तर्क लेने और पंक्तियों को योग करने के लिए एक आर स्क्रिप्ट लिखी है।

#! /usr/local/bin/R
file=commandArgs(trailingOnly=TRUE)[1]
sum(as.numeric(readLines(file)))

इसे "data.table" या "vroom" पैकेज के साथ देखा जा सकता है:

#! /usr/local/bin/R
file=commandArgs(trailingOnly=TRUE)[1]
sum(data.table::fread(file))

#! /usr/local/bin/R
file=commandArgs(trailingOnly=TRUE)[1]
sum(vroom::vroom(file))

बेंचमार्किंग

एक ही बेंचमार्किंग डेटा @glenn jackman के रूप में ।

for ((i=0; i<1000000; i++)) ; do echo $RANDOM; done > random_numbers

उपरोक्त आर कॉल की तुलना में, स्क्रिप्ट के रूप में R 3.5.0 को चलाना अन्य तरीकों (समान लिनक्स डेबियन सर्वर पर) के बराबर है।

$ time R -e 'sum(scan("random_numbers"))'  
 0.37s user
 0.04s system
 86% cpu
 0.478 total

रीडलाइन के साथ आर स्क्रिप्ट

$ time Rscript sum.R random_numbers
  0.53s user
  0.04s system
  84% cpu
  0.679 total

Data.table के साथ स्क्रिप्ट

$ time Rscript sum.R random_numbers     
 0.30s user
 0.05s system
 77% cpu
 0.453 total

स्क्रिप्ट के साथ आर

$ time Rscript sum.R random_numbers     
  0.54s user 
  0.11s system
  93% cpu
  0.696 total

अन्य भाषाओं के साथ तुलना

यहाँ संदर्भ के लिए एक ही हार्डवेयर पर सुझाए गए कुछ अन्य तरीकों के रूप में

अजगर 2 (2.7.13)

$ time python2 -c "import sys; print sum((float(l) for l in sys.stdin))" < random_numbers 
 0.27s user 0.00s system 89% cpu 0.298 total

अजगर 3 (3.6.8)

$ time python3 -c "import sys; print(sum((float(l) for l in sys.stdin)))" < random_number
0.37s user 0.02s system 98% cpu 0.393 total

रूबी (2.3.3)

$  time ruby -e 'sum = 0; File.foreach(ARGV.shift) {|line| sum+=line.to_i}; puts sum' random_numbers
 0.42s user
 0.03s system
 72% cpu
 0.625 total

पर्ल (5.24.1)

$ time perl -nle '$sum += $_ } END { print $sum' random_numbers
 0.24s user
 0.01s system
 99% cpu
 0.249 total

Awk (4.1.4)

$ time awk '{ sum += $0 } END { print sum }' random_numbers
 0.26s user
 0.01s system
 99% cpu
 0.265 total
$ time awk '{ sum += $1 } END { print sum }' random_numbers
 0.34s user
 0.01s system
 99% cpu
 0.354 total

सी (क्लैंग संस्करण 3.3; gcc (डेबियन 6.3.0-18) 6.3.0)

 $ gcc sum.c -o sum && time ./sum < random_numbers   
 0.10s user
 0.00s system
 96% cpu
 0.108 total

अतिरिक्त भाषाओं के साथ अद्यतन करें

लुआ (5.3.5)

$ time lua -e 'sum=0; for line in io.lines() do sum=sum+line end; print(sum)' < random_numbers 
 0.30s user 
 0.01s system
 98% cpu
 0.312 total

tr (8.26) को bash में समयबद्ध होना चाहिए, न कि zsh के साथ संगत

$time { { tr "\n" + < random_numbers ; echo 0; } | bc; }
real    0m0.494s
user    0m0.488s
sys 0m0.044s

sed (4.4) को bash में समयबद्ध होना चाहिए, zsh के अनुरूप नहीं

$  time { head -n 10000 random_numbers | sed ':a;N;s/\n/+/;ta' |bc; }
real    0m0.631s
user    0m0.628s
sys     0m0.008s
$  time { head -n 100000 random_numbers | sed ':a;N;s/\n/+/;ta' |bc; }
real    1m2.593s
user    1m2.588s
sys     0m0.012s

ध्यान दें: sed कॉल अधिक मेमोरी के साथ सिस्टम पर तेजी से काम करने लगती हैं (ध्यान दें कि बेंचमार्किंग सेड के लिए उपयोग किए जाने वाले छोटे डेटासेट)

जूलिया (0.5.0)

$ time julia -e 'print(sum(readdlm("random_numbers")))'
 3.00s user 
 1.39s system 
 136% cpu 
 3.204 total
$  time julia -e 'print(sum(readtable("random_numbers")))'
 0.63s user 
 0.96s system 
 248% cpu 
 0.638 total

ध्यान दें कि आर के रूप में, फ़ाइल I / O विधियों का प्रदर्शन अलग है।

Answer 19

C ++ "वन-लाइनर":

#include <iostream>
#include <iterator>
#include <numeric>
using namespace std;

int main() {
    cout << accumulate(istream_iterator<int>(cin), istream_iterator<int>(), 0) << endl;
}

Answer 20

मनोरंजन के लिए एक और

sum=0;for i in $(cat file);do sum=$((sum+$i));done;echo $sum

या केवल एक और बकवास

s=0;while read l; do s=$((s+$l));done<file;echo $s

लेकिन जाग समाधान शायद सबसे अच्छा है क्योंकि यह सबसे कॉम्पैक्ट है।

Answer 21

C हमेशा गति के लिए जीतता है:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {
    ssize_t read;
    char *line = NULL;
    size_t len = 0;
    double sum = 0.0;

    while (read = getline(&line, &len, stdin) != -1) {
        sum += atof(line);
    }

    printf("%f", sum);
    return 0;
}

1M नंबर (उसी मशीन / इनपुट के रूप में मेरे अजगर जवाब के लिए समय):

$ gcc sum.c -o sum && time ./sum < numbers 
5003371677.000000
real    0m0.188s
user    0m0.180s
sys     0m0.000s

Comments

सबसे बढ़िया उत्तर! बेस्ट स्पीड)

— फोरट्रान

Answer 22

रूबी के साथ:

ruby -e "File.read('file.txt').split.inject(0){|mem, obj| mem += obj.to_f}"

Comments

एक अन्य विकल्प (जब इनपुट STDIN से है) ruby -e'p readlines.map(&:to_f).reduce(:+)'।

— निसेटमा

Answer 23

मुझे नहीं पता कि क्या आप इससे बेहतर कर सकते हैं, इस पर विचार करते हुए आपको पूरी फाइल पढ़ने की जरूरत है।

$sum = 0;
while(<>){
   $sum += $_;
}
print $sum;

Comments

बहुत पठनीय है। पर्ल के लिए। लेकिन हाँ, यह कुछ ऐसा ही होने जा रहा है ...

— dmckee --- पूर्व-मध्यस्थ kitten

$_डिफ़ॉल्ट चर है। आपके द्वारा उपयोग किए जाने पर लाइन इनपुट ऑपरेटर, <>डिफ़ॉल्ट रूप से इसमें परिणाम डालता <>है while।

— ब्रायन डी फ़ो

@ मर्क, $_विषय चर है - यह 'यह' की तरह काम करता है। इस मामले में यह <> प्रत्येक पंक्ति को असाइन करता है। कोड अव्यवस्था को कम करने और एक-पंक्ति लिखने में मदद करने के लिए इसे कई स्थानों पर उपयोग किया जाता है। स्क्रिप्ट कहती है "योग को 0 पर सेट करें, प्रत्येक पंक्ति को पढ़ें और इसे योग में जोड़ें, फिर योग को प्रिंट करें।"

— दोतोआद

@Stefan, चेतावनियों और सख्ती के साथ, आप घोषणा करना और आरंभ करना छोड़ सकते हैं $sum। चूंकि यह इतना सरल है, आप एक स्टेटमेंट संशोधक का भी उपयोग कर सकते हैं while:$sum += $_ while <>; print $sum;

— daotoad

Answer 24

मैंने इसका परीक्षण नहीं किया है लेकिन यह काम करना चाहिए:

cat f | tr "\n" "+" | sed 's/+$/\n/' | bc

यदि आप ईओएफ और ईओपी का इलाज नहीं करते हैं, तो आपको बीसी (ईको के माध्यम से) से पहले स्ट्रिंग में "एन" जोड़ना होगा।

Comments

यह काम नहीं करता है। bc"+" और अंत में newline की कमी के कारण एक सिंटैक्स त्रुटि जारी करता है। यह काम करेगा और यह एक बेकार उपयोग को समाप्त करता है cat: { tr "\n" "+" | sed 's/+$/\n/'| bc; } < numbers2.txt या <numbers2.txt tr "\n" "+" | sed 's/+$/\n/'| bc

— अगली सूचना तक रोक दिया गया।

tr "\n" "+" <file | sed 's/+$/\n/' | bc

— भूतडॉग ghost४

Answer 25

यहाँ एक और है:

open(FIL, "a.txt");

my $sum = 0;
foreach( <FIL> ) {chomp; $sum += $_;}

close(FIL);

print "Sum = $sum\n";

Answer 26

आप Alacon साथ यह कर सकते हैं - के लिए आदेश-पंक्ति उपयोगिता Alasql डेटाबेस के ।

यह Node.js के साथ काम करता है, इसलिए आपको Node.js और उसके बाद Alasql को इंस्टॉल करना होगा पैकेज :

TXT फ़ाइल से राशि की गणना करने के लिए आप निम्नलिखित कमांड का उपयोग कर सकते हैं:

> node alacon "SELECT VALUE SUM([0]) FROM TXT('mydata.txt')"

Answer 27

सभी नई लाइनों को बदलना +, जोड़ना 0और Rubyदुभाषिए को भेजना आसान नहीं है ?

(sed -e "s/$/+/" file; echo 0)|irb

यदि आपके पास नहीं है irb, तो आप इसे भेज सकते हैं bc, लेकिन आपको पिछले एक ( echo) को छोड़कर सभी नए समाचारों को निकालना होगा । इसके लिए उपयोग करना बेहतर है tr, जब तक कि आपके पास पीएचडी न हो sed।

(sed -e "s/$/+/" file|tr -d "\n"; echo 0)|bc

Answer 28

गो में:

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
)

func main() {
    scanner := bufio.NewScanner(os.Stdin)
    sum := int64(0)
    for scanner.Scan() {
        v, err := strconv.ParseInt(scanner.Text(), 10, 64)
        if err != nil {
            fmt.Fprintf(os.Stderr, "Not an integer: '%s'\n", scanner.Text())
            os.Exit(1)
        }
        sum += v
    }
    fmt.Println(sum)
}

Comments

"64" क्या है? "10" मुझे लगता है कि आधार है?

— पीटर के

हाँ, 10 आधार है। 64 बिट्स की संख्या है, यदि परिणामी इंट को कई बिट्स के साथ नहीं दिखाया जा सकता है तो एक त्रुटि वापस आ जाती है। देखें golang.org/pkg/strconv/#ParseInt

— dwurf

Answer 29

बैश रूप

raw=$(cat file)
echo $(( ${raw//$'\n'/+} ))

$ wc -l file
10000 file

$ time ./test
323390

real    0m3,096s
user    0m3,095s
sys     0m0,000s

Answer 30

Awk का उपयोग करके शेल में, मैंने ऐसा करने के लिए स्क्रिप्ट के नीचे उपयोग किया है:

    #!/bin/bash


total=0;

for i in $( awk '{ print $1; }' <myfile> )
do
 total=$(echo $total+$i | bc )
 ((count++))
done
echo "scale=2; $total " | bc