Команда оболонки для підсумовування цілих чисел, одне на рядок?

Я шукаю команду, яка прийме (як введення) кілька рядків тексту, кожен рядок містить одне ціле число, і виведе суму цих цілих чисел.

Як невеликий фон, у мене є файл журналу, який включає вимірювання часу. Через привітання до відповідних рядків і трохи sedпереформатування я можу перерахувати всі таймінги у цьому файлі. Я хотів би опрацювати загальне. Я можу передавати цей проміжний висновок будь-якій команді, щоб зробити остаточну суму. Я завжди використовував exprу минулому, але якщо він не працює в режимі RPN, я не думаю, що він впорається з цим (і навіть тоді це було б складно).

Як я можу отримати підсумовування цілих чисел?

Трохи awk повинен це зробити?

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

Примітка: деякі версії awk мають деяку дивну поведінку, якщо ви збираєтесь додати щось, що перевищує 2 ^ 31 (2147483647). Дивіться коментарі для отримання додаткової інформації. Одне з пропозицій - використовувати, 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:

$ 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, ось робочий скрипт Python, який реалізує деякі команди з dcта виконує 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

Мої п’ятнадцять центів:

$ 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 мільйонів, які можна було виконати на моїй машині менше ніж за хвилину для декількох рішень.

Ось результати:

Пітон

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

Вставити & Bc

Це втратило пам'ять на моїй машині. Він працював на половину розміру вводу (50 мільйонів чисел):

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

Тому я здогадуюсь, що для 100 мільйонів чисел це знадобилося б ~ 35s.

Perl

:; 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, який значно повільніше (22 секунди), так само швидко, як і популярне рішення Awk.

Найшвидше рішення на основі стандартних інструментів - 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-утиліти, хоча це може бути зайвим для того, що вам потрібно. Це набір програм для маніпулювання числами в оболонці і може робити кілька чудових речей, включаючи, звичайно, додавання їх. Це трохи застаріло, але вони все ще працюють і можуть бути корисними, якщо вам потрібно зробити щось більше.

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

Тут ви знайдете:
Найелегантніший одношаровий корпус Unix для підрахунку списку чисел довільної точності?

І ось його особливі переваги перед 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

Ви можете це зробити в python, якщо вам комфортно:

Не перевірено, просто набрано:

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

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)

Вибачте заздалегідь за читабельність задніх планок ("` "), але вони працюють в оболонках, окрім башма, і, таким чином, є більш зручними. Якщо ви використовуєте оболонку, яка приймає її, формат $ (команда ...) набагато легше читається (і, таким чином, налагоджується), ніж "команда ...", тому не соромтесь змінювати для вашого розуму.

У моїй системі 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
}