Sum the numbers on standard in

Question

Consider a stream/file with one integer per line. For example:

123
5
99

Your code should output the sum of these numbers, that is 227.

The input format is strictly one integer per line. You cannot, for example, assume the input is on one line as an array of integers.

You can take input either from STDIN, in form of a filename, or a file with a name of your choice; you can choose which one. No other ways of getting input are allowed.

The input will contain at least one integer. You can assume all integers are non-negative and that their total sum is less than 232.

Answer 1

Pyke, 4 bytes

zbrs

Try it online!

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

Answer 2

GS2, 2 bytes

Wd

Try it online!

How it works

    (implicit) Read all input from STDIN an push it as a string.
W   Extract all integers, pushing a single array.
    For input x, this executes map(int, re.findall(r'-?\d+', x)) internally.
 d  Take the sum.

Answer 3

Batch, 55 bytes

@set s=0
@for /f %%n in (%1)do @set/as+=%%n
@echo %s%

Takes the file to be summed as a command-line parameter.

Answer 4

MATLAB: 17 bytes

sum(dlmread('x'))

Assumes a file named 'x' in current directory. dlmread reads numeric values from a file using delimiters - if no delimiter is specified as the second argument, it will infer from the file type. It successfully infers \n as the delimiter in a file as specified by the question, then uses sum to add them up.

Answer 5

Python 2, 50 45 43 bytes

Pretty self-explanatory.

s=0
try:
    while 1:s+=input()
except:print s

Try it online

Answer 6

Powershell, 18 Bytes

(gc 1)-join"+"|iex

this assumes the file is named '1' with no extension.

alternate 24 byte version, takes filename as input:

(gc "$args")-join"+"|iex

explanation:

( get content of the file "$args" ) then -join the lines together with a "+" to form a valid-syntax sum, then | invoke expression to calculate it as if it was typed into the console directly.

if output is allowed in the following format:

Count    : 3
Average  :
Sum      : 227
Maximum  :
Minimum  :
Property :

then gc 1|measure -s is a valid 15 byte solution, thanks to @AdmBorkBork for pointing that out.

Answer 7

C#, 121 bytes

Java, but no C#? That will not do...

using C=System.Console;class P{static void Main(){int a=0,b;for(;int.TryParse(C.ReadLine(),out b);)a+=b;C.WriteLine(a);}}

Try it Online

Since this score is worse than Java's, we'd better provide a 95 byte context-less function also:

using C=System.Console;int S(){int a=0,b;for(;int.TryParse(C.ReadLine(),out b);)a+=b;return a;}

Formatted and commented:

using C=System.Console;

class P
{
    static void Main()
    {
        int a=0,b; // a is accumulator, b is tempory storage
        for(;int.TryParse(C.ReadLine(),out b);) // read a line, try to parse it as an integer (expects a trailing new-line)
            a+=b; // add to accumulator
        C.WriteLine(a); // print accumulator
    }
}

I was really hoping to have some code like the following:

int a=0,b=0,c;
for(;(c=C.Read())>0;)
    b=c<15?(a+=b)*0:b*10+c-48;
C.WriteLine(a);

But it just doesn't pay :(

Just for fun, the try...catch solution is also 121 bytes

using C=System.Console;class P{static void Main(){int a=0;try{for(;;)a+=int.Parse(C.ReadLine());}catch{}C.WriteLine(a);}}

Answer 8

Pip, 4 bytes

3 bytes of code, +1 for -r flag.

$+g

Try it online!

$+g is the standard "sum all inputs" program--read it as fold-plus(arglist). Normally the arglist is taken from command-line arguments. The -r flag takes it from lines of stdin instead.

Answer 9

PostScript, 11

Consists of two files. File A: (2 bytes)

0[

File B: (8 bytes tokenized)

]{add}forall =

Invoke as: (1 byte for extra file)

$ gs a inputfile b

This takes advantage of the fact that the input format is also valid PostScript code that just pushes all the numbers on the stack.

This allows it to very cheaply create an array from them over which it can iterate, by using multiple files to place an initial value for the summation and the opening brace on the stack before the input file.

Answer 10

QBasic 4.5, 61 59 bytes

Since QBasic isn't the greatest with streams, the input is assumed in a file called "a".

Minus 2 bytes because @DLosc showed me an alternate syntax for one of QBasic's most iconic commands. Does QBasic really hold no secrets for you?

OPEN"I",1,"a"
WHILE EOF(1)=0:INPUT#1,b$:x=x+VAL(b$)
WEND:?x

Answer 11

Go, 146 bytes

package main
import("bufio";"os";"strconv")
func main(){
s:=bufio.NewScanner(os.Stdin)
n:=0
for s.Scan(){m,_:=strconv.Atoi(s.Text())
n+=m
print(n)}}

Answer 12

Cubix, 15 bytes

I have two versions to do this. The first (and longest) is to specification. This will work with non negative integers only. A negative integer will be treated as a end of input, but zeros will be handled correctly.

O<u;Ii?;+...@._

Try it here
Expanded onto the cube

    O <
    u ;
I i ? ; + . . .
@ . _ . . . . .
    . .
    . .

This essentially reads in an integer and the seperator. If the separator is negative (EOF or negative) redirect up into a path that will remove two items from the stack, output the already summed results, grab a superfluous input and exit. Otherwise if the input is non negative remove from the stack then sum. This creates a rolling total.

The shorter (8 byte) non-compliant version will handle non-zero integers, but it treats 0 on the stack as the end of input.

@O;UI!W+

Try it here

    @ O
    ; U
I ! W + . . . .
. . . . . . . .
    . .
    . .

Answer 13

GNU sed + bc, 34 bytes

:
$!N
$!b
y:\n:+:
s:.*:echo &|bc:e

Try it online!

It is possible to do a shell call from inside sed, and as such I use bc to calculate the sum. Lines 1 to 4 only prepare the input necessary for that calculation. This works for negative numbers as well.

Explanation:

:                    # start reading loop
$!N                  # if not EOF, read and append a new input line to pattern
$!b                  # repeat
y:\n:+:              # turn all newlines into pluses
s:.*:echo &|bc:e     # shell call to bc with pattern as input (calculates sum)
                     # implicit printing

Pure GNU sed program: 236 + 1(r flag) = 237 bytes (as promised some time ago)

There are no data types or any math operations in sed. I have tried various methods, but it turns out that concatenating the numbers in unary format and converting the result back to decimal is the simplest way. This works for non-negative integers only, compared to the code above, however this is precisely what the challenge stated in the first place.

G;s:\n::
# concatenate current decimal number with the intermediary unary sum, if any
h;:;s:\w::2g;y:9876543210:87654321\t :;/ /!s:;|$:@:;/\s/!t;x;s:.::;x;G;s:;.*::m;s:\s::g;/\w/{s:@:&&&&&&&&&&:g;t}
# convert the decimal number to unary (using '@' as digit)
y:@:;:
# change unary digit from '@' to ';', to not interfere with above on the next cycle
h;$!d
# store intermediary unary sum and start next reading cycle if input lines left
s:^:0:;/;/{:d;s:^9+:0&:;s:.9*;:/&:;h;s:.*/::;y:0123456789:1234567890:;x;s:/.*::;G;s:\n::;s:;::;/;/td}
# convert final unary sum to decimal (result), plus implicit printing at the end

Try it online!

The program does bignum arithmetic, as long as sed can store in memory the unary result.

Answer 14

Java 7, 109 Bytes

import java.util.*;int x;int s(){Scanner a=new 
Scanner(System.in);while(a.hasNext())x+=a.nextInt();return x;}

Try it!

Reads from System.in

Answer 15

QBIC, 19 bytes

{_?~A=Z|_Xp\p=p+!A!

Explanation

{        DO infinitely
_?       Ask for user input, save as A$
~A=Z     IF input was nothing (Z$ = "")
|_Xp     THEN QUIT, printing the total
\p=p+    ELSE increase the total by
     A   the given input
    ! !  cast as a number

Answer 16

Implicit, 4 3 bytes

©1Þ

I'm going to add a builtin for ©1 eventually (e.g. when I'm done working on bitwise). (Just kidding, I'm never going to get around to it.)

Explanation:

©1Þ
©1   consume all input as integers
  Þ  sum the entire stack

Try it online!

Answer 17

Tcl, 33 bytes

puts [expr [join [read stdin] +]]

Try it online!

Answer 18

T-SQL, 60 59 bytes

SELECT 0a INTO n;BULK INSERT n FROM'd:n'SELECT SUM(a)FROM n

This is the kind of thing that SQL was designed to do, surprised there isn't already an answer for it. Tested on MS SQL 2012.

SELECT 0a INTO n; is slightly shorter than CREATE TABLE n(a INT). Adding a zero row doesn't change the total.

Text file named n (no extension) is located in the current folder on the D: drive. BULK INSERT is shorter and easier than other file import options like SELECT FROM OPENROWSET(BULK) or EXEC xp_cmdshell 'bcp.exe'.

Of course if input is allowed via a pre-existing table, per our normal I/O standards, then this would be trivial (19 bytes):

SELECT SUM(a)FROM n

But of course this challenge is all about the IO...

Answer 19

Labyrinth, 8 bytes

?+
;,;!@

Try it online!

The left-most 2x2 block is the main loop:

?   Read integer.
+   Add to running total (initially zero).
,   Read character. 10 as long as there is another input, -1 at EOF which will
    exit the loop.
;   Discard the 10.

Once we hit EOF, the IP moves east from the ,.

;   Discard the -1.
!   Output the sum.
@   Terminate the program.

Answer 20

Java 7, 111 bytes

import java.util.*;int c(){Scanner c=new Scanner(System.in);int r=0;for(;c.hasNext();r+=c.nextInt());return r;}

Takes the input from STDIN.

Try it here.

Answer 21

JavaScript (Node.js), 124 bytes

t=0;
r=require('readline').createInterface({input:process.stdin});
r.on('line',l=>{t-=-l});
r.on('close',()=>console.log(t))

Try it online!

Answer 22

Julia, 44 bytes

print(sum(map(s->parse(Int,s),readlines())))

Answer 23

Jellyfish, 24 bytes

p
/
+
j, ,']
1'[J-1
   0

Try it online!

Explanation

Reading input isn't very flexible in Jellyfish. In particular, there's no easy way to read a variable number of integers from STDIN, except as a list literal. So the majority of this code is input.

The shortest way I've found is to read all of STDIN as a string, then wrap it in [...] and then evaluate the string. Thankfully, Jelly's parser only looks for whitespace as a separator in lists, not specifically for space characters. So the linefeed separation required by the challenge works.

So let's build up the code from the bottom:

   J-1
   0

Read all input.

   ,']
   J-1
   0

Append ].

 , ,']
 '[J-1
   0

Prepend [.

j, ,']
1'[J-1
   0

Evaluate.

/
+
j, ,']
1'[J-1
   0

Fold addition (in other words, sum).

p
/
+
j, ,']
1'[J-1
   0

Print the result.

Answer 24

C++, 99 Bytes

using namespace std;int main(){string a;int b=0;while(1){getline(cin,a);cout<<(b+=stoi(a))<<"\n";}}

Not my finest work, and there's probably a far better way to go about doing this. Still, I figured that using a string was the optimal way of doing things, seeing as I felt conversions with 'cin' would take up a vast majority of my code otherwise.

Enjoy!

Answer 25

Scala, 48 bytes

print(io.Source.stdin.getLines.map(_.toInt).sum)

Answer 26

JavaScript (Node.js), 112 bytes

Improvements upon the other JavaScript answer and comment below it.

a=0
require('readline').createInterface({input:process.stdin}).on('line',l=>a+=+l).on('close',_=>console.log(a))

Try it online!

Given the split module (npm install split), it's much shorter:

JavaScript (Node.js) with split module, 90 bytes

a=0
process.stdin.pipe(require('split')()).on('data',l=>a+=+l).on('end',_=>console.log(a))

Answer 27

REXX, 47 bytes

s=0
pull n
do until n=''
  s=s+n
  pull n
  end
say s

Answer 28

Alice, 11 bytes

/o
\i@/Hd&+

Try it online!

This feels a bit suboptimal with all those mirrors (and also because the H could also be a +, possibly allowing reuse there), but so far I've only found a handful of different 11-byte solutions.

Explanation

/o
\i@/...

While it's sometimes possible to shorten it, this seems to be a good pattern for programs which a) one or more integers as input, b) transform them with a linear program in Cardinal mode (i.e. integer processing mode), c) want to output one integer. The instruction pointer (IP) first moves from / to / bouncing through the i which reads all input. Then the ... is executed and the IP wrap around to the wrong. The \ puts the IP again in Ordinal mode where o prints the integer as a decimal string and @ terminates the program. So that's the framework I'm using here.

The core of the program is then just four commands:

H   Compute the absolute value of the top of the stack. The reason we're doing this
    is that the stack still holds the entire input as a string. But as soon as you
    try to pop a value in Cardinal mode, that string gets implicitly converted
    to the integers it contains. So in this case, the H itself doesn't really
    do anything but it forces the input to be converted. We could also use
    + here and already sum the top two values (if there's only one value it
    would get added to an implicit zero, so that's fine).
d   Push the stack depth, i.e. the number of integers in the input.
&   Execute the next command that many times.
+   Add the top two numbers of the stack. Of course this is one more addition
    than we need, but there are only implicit zeros beneath the input so
    they don't change the result.

Answer 29

JavaScript (Node.js), 78 bytes

process.stdin.on("data",r=>console.log((""+r).split`
`.reduce((a,v)=>+a+ +v)))

No requires needed for this one, just native NodeJS.

Try it online!

Answer 30

Dart, 96 bytes (non async), 132 bytes (async)

Non async:

import'dart:io';main(){_ s;_ i=0;while((s=stdin.readLineSync())!=null)i+=int.parse(s);print(i);}

Dart allows you to define local variables with types that don't exist when running in uncheck mode (which is the default mode). This program doesn't function in checked mode.

Async:

import'dart:io';import'dart:convert';main()async=>print((await UTF8.decodeStream(stdin)).split("\n").fold(0,(p,e)=>p+int.parse(e)));

The async version is longer, easier to read, and faster than the sync version. It also works in checked mode. UTF8.decodeStream decodes the entire stream into a Future, await waits for this to finish and gives a String, the string is split by line into List, and finally the strings are folded into the final result.