考虑每行一个整数的流/文件。例如：

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。

Gif或它没有发生：

或在线尝试！（感谢Dennis的设置！）

说明

运行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

另一个shell的答案！

Perl 6、13个字节

say sum lines

试试吧

说明

• lines()返回命令行列表$*IN或$*ARGFILES“魔术”命令行输入句柄。
• sum(…)已添加到Perl 6中，以便[+] List针对Positionalals进行优化，可以计算它们的总和而不生成所有值，例如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感谢Martin Ender

.*
$*
1

在线尝试！

转换为一元：

.*
$*

计算1s 的数量：

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，输入$_每次读取一行，每次存储一次。我们将其$\用作累加器，因为多亏了-pflag，它才隐式打印在末尾。不匹配的}{被使用，从而-p标志只打印$\在端而不是打印一次$_且$\在每一行读取像通常那样。

纯Bash，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

dc，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')（显然）打开。但是，它们是可迭代的。每次您遍历文件时，都会得到下一行。因此map遍历每个列表，调用int，然后对结果列表求和。

以文件名作为输入进行调用。（即f('numbers.txt')）

使用map(int, open(n))而不是列表解析来保存8个字节。原始代码：

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.

Brachylog，4个字节

ṇịᵐ+

在线尝试！

说明

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

纯bash 30

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

在线尝试。

• read将输入文件放入变量中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.

q，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)

直流电，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是递归调用的。Modern dc为此类事情实现了尾递归，因此不必担心堆栈溢出。

派克（Pyke），4个字节

zbrs

在线尝试！

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