한 줄에 하나씩 정수를 합하는 쉘 명령?

여러 줄의 텍스트를 입력하고 각 줄에 단일 정수가 들어 있고 이러한 정수의 합계를 출력하는 명령을 찾고 있습니다.

약간의 배경으로, 타이밍 측정을 포함하는 로그 파일이 있습니다. 관련 줄에 대한 grepping과 약간의 sed재 포맷을 통해 해당 파일의 모든 타이밍을 나열 할 수 있습니다. 나는 총계를 해결하고 싶습니다. 최종 합계를 수행하기 위해이 중간 출력을 모든 명령에 파이프 할 수 있습니다. 나는 항상 expr과거에 사용했지만 RPN 모드에서 실행되지 않으면 이것에 대처할 것이라고 생각하지 않습니다 (그리고 심지어 까다로울 것입니다).

정수의 합계를 어떻게 얻을 수 있습니까?

조금 어색해야합니까?

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

참고 : 2 ^ 31 (2147483647)을 초과하는 항목을 추가하려는 경우 일부 버전의 awk에서 이상한 동작이 발생합니다. 더 많은 배경에 대한 의견을 참조하십시오. 한 가지 제안은 다음 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 -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다음 명령 중 일부 명령을 구현 dc하고 위 명령의 Python 버전을 실행하는 작동하는 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

나의 15 센트 :

$ 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).
• 진짜 원 라이너입니다
• 엄청난 양의 숫자 (1 억)를 추가 할 수 있으며
• 빠릅니다 (분 이상 걸리는 것을 무시했습니다).

나는 항상 몇 가지 솔루션에 대해 1 분 안에 내 컴퓨터에서 가능한 1 ~ 1 억의 숫자를 추가했습니다.

결과는 다음과 같습니다.

파이썬

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

어 wk

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

붙여 넣기 및 BC

컴퓨터의 메모리가 부족합니다. 입력 크기의 절반 (5 천만 숫자)으로 작동했습니다.

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

그래서 1 억 개의 숫자에 대해 ~ 35s를 차지했을 것입니다.

펄

:; 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 만 설치했는데, 이는 인기있는 Awk 솔루션만큼 정확하게 (22 초) 상당히 느립니다.

표준 툴을 기반으로하는 가장 빠른 솔루션은 Perl (15s)입니다.

일반 배쉬 원 라이너

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

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

BASH 솔루션,이 명령을 수행하려는 경우 (예 : 자주 수행해야하는 경우) :

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

그런 다음 사용법 :

addnums < /tmp/nums

AWK가 찾고있는 것 같습니다.

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

표준 입력을 통해 숫자 목록을 전달하거나 숫자를 포함하는 파일을 매개 변수로 전달하여이 명령을 사용할 수 있습니다.

다음은 bash에서 작동합니다.

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, 읽기 쉬운 패키지 또는 옵션이 필요하지 않습니다.

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

Sebastian은 하나의 라이너 스크립트를 지적했습니다.

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

$ 고양이 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

그러나이 파일은 파일을 비방하므로 큰 파일에는 사용하지 않는 것이 좋습니다. slurping을 피하는 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

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)

백틱 ( "`")의 가독성을 사전에 사과하지만, bash 이외의 쉘에서 작동하므로 붙여 넣기가 더 쉽습니다. 그것을 받아들이는 쉘을 사용한다면, $ (command ...) 형식은`command ...`보다 훨씬 더 읽기 쉽고 (따라서 디버깅 가능하다), 당신의 정신을 자유롭게 수정하십시오.

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

한 줄 씩만 합산하려는 경우입니다. 그러나 데이터 파일 의 모든 숫자에 대해

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

btw 데스크탑에서 빠른 작업을 수행 해야하는 경우 다음을 사용합니다.

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