Рассмотрим поток / файл с одним целым числом в строке. Например:

123
5
99

Ваш код должен выводить сумму этих чисел, то есть 227.

Формат ввода строго одно целое число в строке. Вы не можете, например, предположить, что вход находится в одной строке как массив целых чисел.

Вы можете получить ввод из STDIN в виде имени файла или файла с именем по вашему выбору; Вы можете выбрать какой. Другие способы получения входных данных не допускаются.

Ввод будет содержать как минимум одно целое число. Вы можете предположить, что все целые числа неотрицательны и что их общая сумма меньше, чем .232

05AB1E , 2 байта

|O

Объяснение:

|   Get input as array
 O  Sum

Попробуйте онлайн!

Bash + coreutils, 16 байт

xargs|tr \  +|bc

Попробуйте онлайн!

Есть два пробела после \. Это работает и для отрицательных чисел.

Объяснение:

xargs             # known trick to turn newlines into spaces, while adding a
                  #trailing newline when printing the result (needed for bc)
|tr \  +          # turn spaces into '+'s
|bc               # calculates the sum

Вы можете спросить, почему tr \\n +|bcне лучше, так как он превращает новые строки прямо в «+». Хорошо, что есть 2 непредвиденные ошибки:

• если вход имеет завершающий символ новой строки, то он преобразуется в завершающий «+», следовательно, после него нет номера для выполнения сложения
• и самая странная проблема заключается в том, что bc требует завершающего символа новой строки после ввода, но вы просто заменили все входные символы новой строки на «+».

MATL , 2 байта

Us

Это ожидает ввода в текстовом файле с именем defin.

Гиф или этого не случилось :

Или попробуйте онлайн! ( спасибо Деннису за настройку! )

объяснение

При запуске программы MATL, если вызванный файл definнайден (имя относится к «вводу по умолчанию»), его содержимое автоматически загружается в виде текста и передается в стек в виде строки перед выполнением кода.

Функция Uоценивает строку, чтобы преобразовать ее в вектор-столбец чисел, и sвычисляет сумму, которая отображается неявно.

Japt , 2 байта

Nx

объяснение

     Implicit: parse STDIN into array of numbers, strings, and arrays
N    Get the resulting parsed array.
 x   Sum.
     Implicit: output result of last expression

Попробуйте онлайн!

Вставить + bc, 13 байт

paste -sd+|bc

Объяснение:

paste -s        Take one line at a time from input
        d+      Joining by '+'
          |bc   Pass as expression to bc

Еще один ответ оболочки!

Perl 6 , 13 байт

say sum lines

Попытайся

объяснение

• lines()возвращает список строк из $*INили $*ARGFILES«волшебной» ввода командной строки ручки.
• sum(…)был добавлен в Perl 6, чтобы позволить [+] Listбыть оптимизированным для Позиционеров, которые могут вычислять их сумму, не генерируя все их значения, как 1..100000
  (я просто подумал, sumчто здесь слишком мило, чтобы использовать, [+]как обычно)
• say(…)вызовите .gistметод для его ввода и напечатайте его с дополнительной новой строкой.

C, 53 байта

r;main(i){for(;~scanf("%d",&i);r+=i);printf("%d",r);}

Python 3 , 28 байт

print(sum(map(int,open(0))))

Взято из этого совета . Мне сказали, что это не будет работать на Windows.

Попробуйте онлайн!

Сетчатка , 11 7 байт

-4 спасибо Мартину Эндеру

.*
$*
1

Попробуйте онлайн!

Преобразовать в одинарный:

.*
$*

Подсчитайте количество 1с:

1

Brain-Flak , 20 байтов

(([]){[{}]{}([])}{})

Попробуйте онлайн!

объяснение

Это решение, созданное Райли в чате . Его решение было:

([])({<{}>{}<([])>}{})

Если вы знакомы с Brain-Flak, это довольно очевидно. Он увеличивает высоту стека и выдает одно значение при обратном отсчете, а в конце - сумму всех прогонов.

Это довольно хороший гольф, но он обнуляет оба, {}и, тем не ([])менее, они будут иметь значения, которые будут отличаться только на единицу, поэтому, если вместо этого мы удалим маски и сделаем одно из двух отрицательных значений, они должны почти аннулироваться.

([])({[{}]{}([])}{})

Так как они всегда отличаются на единицу, у нас есть неудачное обстоятельство, когда наш ответ всегда не соответствует высоте стека. Чтобы исправить это, мы просто перемещаем начало толчка, чтобы охватить первую высоту стека.

(([]){[{}]{}([])}{})

Python 2, 40 байт

import sys;print sum(map(int,sys.stdin))

R 11 байт

sum(scan())

scanпринимает входные данные, один номер в строке. И sum, ну, суммы.

Perl 5 , 9 байт

8 байтов кода + -pфлаг.

$\+=$_}{

Попробуйте онлайн!

При -pэтом вход считывается по одной строке за раз, сохраняется в $_каждый раз. Мы используем в $\качестве аккумулятора, потому что благодаря -pфлагу он неявно печатается в конце. Используются несоответствующие }{, поэтому -pфлаг печатает только $\один раз в конце вместо печати, $_и $\в каждой строке он читает, как обычно.

Чистый Баш, 37 36 байт

Спасибо @KevinCruijssen за байт!

while read a;do((b+=a));done;echo $b

Попробуйте онлайн!

Haskell, 32 байта

interact$show.sum.map read.lines

Попробуйте онлайн! ,

interactсобирает весь ввод из stdin, передает его функции, указанной в качестве аргумента, и печатает строку, полученную из этой функции. Функция:

            lines   -- split input into list of lines at nl
      map read      -- convert every line to a number (read is polymorphic,
                    -- but as want to sum it later, the type checker knows
                    -- it has to be numbers)
    sum             -- sum the list of numbers
show                -- convert back to string

PHP, 22 байта

<?=array_sum(file(t));

Предполагается, что существует файл с именем «t» со списком целых чисел.

file()открывает файл и возвращает массив, в каждой строке которого хранится отдельный элемент массива. array_sum()суммирует все элементы в массиве.

Awk, 19 байт

{s+=$1}END{print s}

Объяснение:

{s+=$1}                For all lines in the input, add to s
        END             End loop
           {print s}    Print s

постоянный ток , 14 байтов

0[+?z2=a]dsaxp

Попробуйте онлайн!

Объяснение:

 [      ] sa   # recursive macro stored in register a, does the following:
  +            # - sum both numbers on stack
               #   (prints to stderr 1st time since there's only 1)
   ?           # - read next line, push to stack as number
    z          # - push size of stack
     2         # - push 2
      =a       # - if stack size = 2, ? yielded something, so recurse
               # - otherwise end macro (implicit)
0              # push 0 (accumulator)
         d     # duplicate macro before storing it
            x  # Call macro
             p # The sum should be on the stack now, so print it

CJam , 5 байтов

q~]1b

Попробуйте онлайн!

Как это работает

q     e# Read all input from STDIN.
 ~    e# Evaluate that input, pushing several integers.
  ]   e# Wrap the entire stack in an array.
   1b e# Convert from base 1 to integer.
      e# :+ (reduce by sum) would work as well, but 1b handles empty arrays.

Python, 38 30 байт

lambda n:sum(map(int,open(n)))

В python файлы открываются open('filename')(очевидно). Они, однако, итерируемы. Каждый раз, когда вы перебираете файл, вы получаете следующую строку. Таким образом, карта перебирает каждый список, вызывая intего, а затем суммирует полученный список.

Вызов с именем файла в качестве ввода. (то есть f('numbers.txt'))

8 байтов сохранены с использованием map(int, open(n))вместо понимания списка. Оригинальный код:

lambda n:sum([int(i)for i in open(n)]) 

Mathematica, 19 байт

Предполагается, что среда Mathematica для ноутбуков.

Tr[#&@@@Import@"a"]

Ожидает, что вход будет в файле a.

Желе , 9 8 байт

ƈFпFỴVS

STDIN на самом деле не вещь желе ...

Попробуйте онлайн!

Как это работает

ƈFпFỴVS  Main link. No arguments. Implicit argument: 0

  п      While loop; while the condition returns a truthy value, execute the body
          and set the return value to the result. Collect all results (including 0,
          the initial return value) in an array and return that array.
ƈ           Body: Yield a character from STDIN or [] if the input is exhausted.
 F          Condition: Flatten, mapping 0 to [], '0' to "0", and [] to [] (falsy).
    F     Flatten the result.
     Ỵ    Split at newlines.
      V   Evaluate the resulting strings.
       S  Take the sum.

Брахилог , 4 байта

ṇịᵐ+

Попробуйте онлайн!

объяснение

ṇ         Split the Input on linebreaks
 ịᵐ       Map: String to Integer
   +      Sum

Чистая Баш, 30

read -d_ b
echo $[${b//'
'/+}]

Попробуйте онлайн.

• reads входной файл за один раз входит в переменную b. -d_говорит, readчто разделитель строки _вместоnewline
• ${b//'newline'/+}заменяет новые строки в bс+
• echo $[ ... ] арифметически оценивает полученное выражение и выводит его.

Vim, 16 байт / нажатий клавиш

:%s/\n/+
C<C-r>=<C-r>"<C-h>

Поскольку V имеет обратную совместимость, вы можете попробовать это онлайн!

Pyth , 3 байта

s.Q

Попробуйте онлайн!

 .Q  Read all of standard input, evaluating each line.
s    Take the sum.

JQ , 5 байт

addплюс флаг командной строки -s .

Например:

% echo "1\n2\n3\n4\n5" | jq -s add
15

На самом деле , 2 байта

kΣ

Попробуйте онлайн!

Объяснение:

kΣ
    (implicit input - read each line, evaluate it, and push it to the stack)
k   pop all stack elements and push them as a list
 Σ  sum
    (implicit output)

DC 22

[pq]sq0[?z2>q+lmx]dsmx

Это кажется более длинным, чем должно быть, но сложно решить, когда будет достигнут конец файла. Единственный способ сделать это - проверить длину стека после? команды.

Попробуйте онлайн .

[pq]                    # macro to `p`rint top-of-stack, then `q`uit the program
    sq                  # save the above macro in the `q` register
      0                 # push `0` to the stack.  Each input number is added to this (stack accumulator)
       [         ]      # macro to:
        ?               # - read line of input
         z              # - push stack length to stack
          2             # - push 2 to the stack
           >q           # - if 2 > stack length then invoke macro stored in `q` register
             +          # - add input to stack accumulator
              lmx       # - load macro stored in `m` register and execute it
                  d     # duplicate macro
                   sm   # store in register `m`
                     x  # execute macro

Обратите внимание, что макрос mвызывается рекурсивно. Современные средства dcреализуют хвостовую рекурсию для такого рода вещей, поэтому не стоит беспокоиться о переполнении стека.

Пайк , 4 байта

zbrs

Попробуйте онлайн!

z    -   input()
 b   -  int(^)
  r  - if no errors: goto start
   s - sum(stack)