පූර්ණ සංඛ්‍යා එකතු කිරීමට ෂෙල් විධානය, එක් පේළියකට එකක්?

මම සොයන්නේ (ආදාන ලෙස) පෙළ පෙළක්, එක් එක් පේළිය තනි නිඛිලයක් අඩංගු වන අතර මෙම නිඛිලවල එකතුව ප්‍රතිදානය කරන විධානයකි.

ටිකක් පසුබිමක් ලෙස, මට කාල මිනුම් ඇතුළත් ලොග් ගොනුවක් ඇත. අදාළ රේඛා සඳහා ග්‍රහණය කර ගැනීම සහ නැවත ආකෘතිකරණය කිරීම තුළින් sedමට එම ගොනුවේ ඇති සියලුම වේලාවන් ලැයිස්තුගත කළ හැකිය. මම සම්පූර්ණ වැඩ කිරීමට කැමතියි. අවසාන මුදල සිදු කිරීම සඳහා මට මෙම අතරමැදි ප්‍රතිදානය ඕනෑම විධානයකට නල කළ හැකිය. මම සෑම විටම exprඅතීතයේ භාවිතා කර ඇත, නමුත් එය ආර්පීඑන් මාදිලියේ ධාවනය නොවන්නේ නම් එය මේ සමඟ සාර්ථකව කටයුතු කරනු ඇතැයි මම නොසිතමි (එවිට පවා එය ව්‍යාකූල වනු ඇත).

පූර්ණ සංඛ්‍යා වල සාරාංශය ලබා ගන්නේ කෙසේද?

බිට් අවුල් එය කළ යුතුද?

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

සටහන: ඔබ 2 ^ 31 (2147483647) ඉක්මවන කිසිවක් එකතු කිරීමට යන්නේ නම්, සමහර අවුල් අනුවාද වල අමුතු හැසිරීම් ඇත. වැඩි පසුබිමක් සඳහා අදහස් බලන්න. එක් යෝජනාවක් භාවිතා කිරීමයි printfවඩා print:

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

පේස්ට් සාමාන්‍යයෙන් බහු ලිපිගොනු පේළි ඒකාබද්ධ කරයි, නමුත් ගොනුවක තනි පේළි තනි පේළියක් බවට පරිවර්තනය කිරීමටද එය භාවිතා කළ හැකිය. පරිසීමක ධජය මඟින් ඔබට x + x වර්ගයේ සමීකරණයක් bc වෙත යැවීමට ඉඩ ලබා දේ.

paste -s -d+ infile | bc

විකල්පයක් ලෙස, ස්ටැඩින් සිට නල මාර්ගයේ,

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

පයිතන් හි එක්-ලයිනර් අනුවාදය:

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

Us ණ ලකුණ සමඟ උපසර්ගය negative ණ සංඛ්‍යා සඳහා පරිවර්තනය කළ යුතු බව සලකන්න 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. ඉහළ අගයන් දෙක තොගයෙන් ඉවත් කර ප්‍රති result ලය නැවත එක් කරන්න
   2. තොගයේ අගයන් දෙකක් හෝ වැඩි ගණනක් තිබේ නම්, "add_top_of_stack" පුනරාවර්තනය කරන්න
2. තොගයේ අගයන් දෙකක් හෝ වැඩි ගණනක් තිබේ නම්, "add_top_of_stack" ධාවනය කරන්න
3. ප්‍රති result ලය මුද්‍රණය කරන්න, දැන් තොගයේ ඉතිරිව ඇති එකම අයිතමය

dcමෙහි ඇති සරල බව සහ බලය සැබවින්ම වටහා ගැනීම සඳහා dc, ඉහත විධානයෙහි පයිතන් අනුවාදයෙන් සමහර විධානයන් ක්‍රියාත්මක කරන සහ ක්‍රියාත්මක කරන ක්‍රියාකාරී පයිතන් පිටපතක් මෙහි ඇත:

### 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 දක්වා සංඛ්‍යා එකතු කළෙමි.

ප්‍රති results ල මෙන්න:

පයිතන්

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

අවුල්

:; seq 100000000 | awk '{s+=$1} END {print s}'
5000000050000000
# 22s

අලවන්න සහ බීසී

මෙය මගේ යන්ත්‍රයේ මතකය නැති වී ගියේය. එය ආදානයේ ප්‍රමාණයෙන් අඩක් (අංක මිලියන 50) වැඩ කළේය:

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

ඒ නිසා මම හිතන්නේ එය මිලියන 100 සඳහා ඩොලර් 35 ක් ගතවනු ඇත.

පර්ල්

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

සී

සංසන්දනය කිරීම සඳහා මම සී අනුවාදය සම්පාදනය කර මෙයද පරීක්‍ෂා කළෙමි, මෙවලම් මත පදනම් වූ විසඳුම් කෙතරම් මන්දගාමීද යන්න පිළිබඳ අදහසක් ලබා ගැනීම සඳහා.

#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 ඇත්ත වශයෙන්ම 8s සමඟ වේගවත් වේ, නමුත් Pypy විසඳුම එකතු කරන්නේ 30% සිට 11s දක්වා ඉතා සුළු පිරිවැයක් පමණි . එහෙත්, සාධාරණ ලෙස කිවහොත්, පයිපී හරියටම සම්මත නොවේ. බොහෝ අය CPython ස්ථාපනය කර ඇති අතර එය සැලකිය යුතු ලෙස මන්දගාමී (22s), ජනප්‍රිය අව්ක් විසඳුම තරම් වේගවත් ය.

සම්මත මෙවලම් මත පදනම් වූ වේගවත්ම විසඳුම වන්නේ පර්ල් (15s) ය.

BASH විසඳුම, ඔබට මෙය විධානයක් කිරීමට අවශ්‍ය නම් (උදා: ඔබට මෙය නිතර කිරීමට අවශ්‍ය නම්):

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

ඉන්පසු භාවිතය:

addnums < /tmp/nums

සරල බාෂ් එක් ලයිනර්

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

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

මම හිතන්නේ AWK යනු ඔබ සොයන දෙයයි:

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

සම්මත ආදානය හරහා අංක ලැයිස්තුව සම්මත කිරීමෙන් හෝ පරාමිතියක් ලෙස සංඛ්‍යා අඩංගු ගොනුව සම්මත කිරීමෙන් ඔබට මෙම විධානය භාවිතා කළ හැකිය.

පහත දැක්වෙන්නේ කඩිනමින් ය:

I=0

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

echo $I

ඔබට අවශ්‍ය දේ සඳහා අධික ලෙස මරා දැමිය හැකි වුවද, ඔබට සංඛ්‍යා-භාවිතයන් භාවිතා කළ හැකිය. මෙය කවචයේ සංඛ්‍යා හැසිරවීම සඳහා වූ වැඩසටහන් සමූහයක් වන අතර ඇත්ත වශයෙන්ම ඒවා එකතු කිරීම ඇතුළුව නව දේවල් කිහිපයක් කළ හැකිය. එය යල්පැන ඇති නමුත් ඒවා තවමත් ක්‍රියාත්මක වන අතර ඔබට තවත් යමක් කිරීමට අවශ්‍ය නම් එය ප්‍රයෝජනවත් වේ.

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

GNU datamash උපයෝගීතාව භාවිතා කිරීම :

seq 10 | datamash sum 1

ප්‍රතිදානය:

55

ආදාන දත්ත අක්‍රමවත් නම්, අවකාශයන් සහ ටැබ් අමුතු ස්ථානවල තිබේ නම්, මෙය ව්‍යාකූල විය හැකිය datamash, පසුව එක්කෝ -Wස්විචය භාවිතා කරන්න :

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

... හෝ trහිස් අවකාශය පිරිසිදු කිරීමට භාවිතා කරන්න:

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

මෙය ඉදිරිපත් කිරීමෙන් වැළකී සිටිය නොහැක:

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

එය මෙතැනින් හමු වේ:
අත්තනෝමතික නිරවද්‍යතාවයේ සංඛ්‍යා ලැයිස්තුවක් එකතු කිරීම සඳහා වඩාත් අලංකාර යුනික්ස් ෂෙල් වන්-ලයිනර්?

අමුතු, බීසී සහ මිතුරන්ට වඩා එහි විශේෂ වාසි මෙන්න:

• එය බෆරින් මත රඳා නොපවතින අතර එමඟින් විශාල යෙදවුම් සමඟ යටපත් නොවේ
• එමගින් සීමාවන් සඳහා නිශ්චිත නිරවද්‍යතාවයක් හෝ පූර්ණ සංඛ්‍යා ප්‍රමාණයක් අදහස් නොකෙරේ (හෙලෝ AWK!)
• පාවෙන ලක්ෂ්‍ය අංක එකතු කිරීමට අවශ්‍ය නම් විවිධ කේත අවශ්‍ය නොවේ

විකල්ප පිරිසිදු පර්ල්, තරමක් කියවිය හැකි, පැකේජ හෝ විකල්ප අවශ්‍ය නොවේ:

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

රූබි පෙම්වතුන් සඳහා

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

මගේ අනුවාදය:

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 ගේ පිළිතුර බලන්න .

පහත සඳහන් දෑ ක්‍රියාත්මක විය යුතුය (ඔබේ අංකය එක් එක් පේළියේ දෙවන ක්ෂේත්‍රය යැයි උපකල්පනය කරන්න).

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

සී (සරල කර නැත)

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)

බැක්ටික්ස් ("` ") කියවීමේ හැකියාව සඳහා කල්තියාම සමාව ඉල්ලන්න, නමුත් මේවා බාෂ් හැර වෙනත් ෂෙල් වෙඩි වලින් ක්‍රියා කරන අතර ඒවා වඩාත් පේස්ට් කළ හැකිය. ඔබ එය පිළිගන්නා කවචයක් භාවිතා කරන්නේ නම්, command (විධානය ...) ආකෘතිය `විධානය ... 'ට වඩා කියවිය හැකි (සහ නිදොස් කළ හැකි) වේ. එබැවින් ඔබේ සිහිබුද්ධිය සඳහා වෙනස් කිරීමට නිදහස් වන්න.

මගේ bashrc හි සරල ශ්‍රිතයක් ඇති අතර එය සරල ගණිත අයිතම ගණනාවක් ගණනය කිරීමට awk භාවිතා කරයි

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

මෙය +, -, *, /, ^,%, වර්ග, පාපය, කොස්, වරහන් .... (සහ තවත් බොහෝ දේ ඔබේ අනුවාදය අනුව) කරනු ඇත ... ඔබට 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

ඔබට අවශ්‍ය වන්නේ ඒවා පේළියකින් පමණක් එකතු කිරීමයි. කෙසේ වෙතත් දත්ත ගොනුවේ ඇති සෑම සංඛ්‍යාවක් සඳහාම

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

btw මට ඩෙස්ක්ටොප් එකෙන් ඉක්මනින් යමක් කිරීමට අවශ්‍ය නම්, මම මෙය භාවිතා කරමි:

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