9
\$\begingroup\$

Given N integers, output the sum of those integers.

Input

You may take the integers in any reasonable format, including:

  • stdin
  • arguments
  • an array or list

Rules

Testcases

n=2, 1, 2 -> 3
n=2, 2, 2 -> 4
n=2, 9, 10 -> 19
n=2, 7, 7 -> 14
n=2, 8, 8 -> 16
n=2, -5, 3 -> -2
n=2, -64, -64 -> -128
n=2, -3, 0 -> -3
n=2, 0, 3 -> 3
n=2, 0, 0 -> 0
n=2, -1, -1 -> -2
n=2, -315, -83 -> -398
n=2, 439, 927 -> 1366
n=3, 1, 2, 3 -> 6
n=3, 2, 2, 5 -> 9
n=3, 0, 9, 10 -> 19
n=3, 7, 0, 7 -> 14
n=3, 8, 8, 0 -> 16
n=3, -5, 3, -2 -> -4
n=3, -64, -64, 16 -> -112
n=3, -3, 0, 0 -> -3
n=3, 0, 3, 0 -> 3
n=3, 0, 0, 0 -> 0
n=3, -1, -1, -1 -> -3
n=3, -315, -83, -34 -> -432
n=3, 439, 927, 143 -> 1509
n=17, -74, 78, 41, 43, -20, -72, 89, -78, -12, -5, 34, -41, 91, -43, -23, 7, -44 -> -29

Testcases with partial sums that exceed 8 bits are only required if your integer type supports each partial sum (if any) and the final result. As a special case, n=2, -64, -64 -> -128 is only required if your integer type can represent -128.

Testcases involving negative integers are only required if your language natively supports negative integers.

Improve this question
\$\endgroup\$
6
  • \$\begingroup\$ I have one which I think is neat enough to be a notable mention though it doesn't strictly abide by the rules. Instead of summing a list, it only adds 2 numbers... Any chance I can still add it and let the votes decide? \$\endgroup\$
    – AviFS
    Mar 24, 2020 at 2:26
  • 2
    \$\begingroup\$ @AviF.S., that would not be a valid solution to the challenge. \$\endgroup\$
    – Shaggy
    Mar 24, 2020 at 13:37
  • \$\begingroup\$ @Avi If you create another function that does the rest of the adding, then yes. Otherwise, no. \$\endgroup\$
    – S.S. Anne
    Mar 24, 2020 at 15:22
  • \$\begingroup\$ I see you've had mercy on languages that don't support numbers that require 8 bits, a generous allowance. Any chance it's also alright if our language doesn't support negative numbers? (I don't mean to keep poking at the question, but I'd really love to be able to submit answers in languages not meant for this sort of thing and still have them be reasonably elegant, even if not short!) \$\endgroup\$
    – AviFS
    Apr 24, 2020 at 18:29
  • \$\begingroup\$ @AviF.S. That's acceptable. The other was not, as that would make the challenge extremely trivial. \$\endgroup\$
    – S.S. Anne
    Apr 24, 2020 at 18:36

53 Answers 53

Reset to default
1
2
14
\$\begingroup\$

Wolfram Language (Mathematica), 2 bytes

Tr finds the trace of the matrix or tensor list 

Tr

Try it online!

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ @a'_' As far as I remember, it sums the elements on the diagonal of a matrix, or, if it's actually a vector, just sums everything. \$\endgroup\$
    – the default.
    Mar 23, 2020 at 5:33
10
\$\begingroup\$

Python 2, 97 95 93 88 87 bytes

Solution that doesn't use the built-in sum, eval or exec:

-2 bytes thanks to @JonathanAllan!
-1 byte thanks to @ovs!

x=y=1
for i in input():x<<=i*(i>0);y<<=abs(i)
y/=x
print" ~"[x<y],len(bin(x/y|y/x)[3:])

Try it online!

Input: a comma separated list of numbers, from stdin.
Output: the sum is printed to stdout. If the sum is negative, the ~ sign is used instead of - due to source code restriction.

How: Let \$p\$ be the sum of all positive numbers in the list, and \$n\$ be the magnitude of the sum of all negative numbers. Then the sum of the list is \$p-n\$.

Let \$x=2^p\$ and \$y=2^n\$, then \$\frac xy=2^{p-n}\$.

Thus if the sum is positive (aka \$x>y\$), we can calculate the sum by counting the number of zeros in the binary representation of \$\frac xy\$. Otherwise, we can calculate the magnitude of the sum as the number of zeros in the binary representation of \$\frac yx\$.

Improve this answer
\$\endgroup\$
3
  • 2
    \$\begingroup\$ x<<=i*(i>0);y<<=abs(i*(i<0)) saves two over using max and min. \$\endgroup\$
    – Jonathan Allan
    Mar 22, 2020 at 23:35
  • \$\begingroup\$ 85 bytes \$\endgroup\$
    – ovs
    Apr 20, 2020 at 13:04
  • \$\begingroup\$ @ovs Thanks! I cannot use -3 since it contains -, but can still save 1 byte with y/=x. \$\endgroup\$
    – Surculose Sputum
    Apr 20, 2020 at 18:38
9
\$\begingroup\$

JavaScript (ES6), 21 bytes

Takes input as an array of integers.

a=>eval(a.join`\x2B`)

Try it online!

JavaScript (ES6), 40 bytes

Takes input as an array of integers.

a=>a.reduce(g=(x,y)=>y?g(x^y,(x&y)*2):x)

Try it online!

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ Amazing formula! Waiting for an explanation on why this will eventually terminate. \$\endgroup\$
    – Surculose Sputum
    Mar 22, 2020 at 22:58
  • 3
    \$\begingroup\$ @SurculoseSputum It is quite similar to a binary addition by hand: the XOR does the addition without the carries which are processed separately by the doubled AND. The recursion stop when there's no more carry. It is described here for instance, and some other variants can be found here. \$\endgroup\$
    – Arnauld
    Mar 22, 2020 at 23:37
6
\$\begingroup\$

APL (dzaima/APL), 2 bytesSBCS

Anonymous tacit prefix function

1⊥

Try it online!

Simply evaluates a "digit" list in base 1.

Improve this answer
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Absolutely brilliant! How ever did it occur to you? The best part is it's no longer than the normal way. Replacing +/ with 1⊥ in all golfed APL has to be the best way of obfuscating and impressing people ever... \$\endgroup\$
    – AviFS
    Mar 22, 2020 at 22:16
  • \$\begingroup\$ @AviF.S. It is a common trick in tacit APL due to it being a dyadic function application rather than a monadic one which cannot be composed with a function on its left. \$\endgroup\$
    – Adám
    Mar 22, 2020 at 22:19
  • \$\begingroup\$ Whoops. Now that it's documented, I feel silly acting like it was so novel... But I do still think it's a brilliant trick! \$\endgroup\$
    – AviFS
    Mar 22, 2020 at 22:22
6
\$\begingroup\$

W, 1 bytes

Takes input as a list and... just a summation function... :-)

J

W j, 0 bytes

Haha, even more cheaty! The j flag automatically evaluates the J command at the end of the source code.
Improve this answer
\$\endgroup\$
0
6
\$\begingroup\$

C (gcc), 50 45 43 38 bytes

f(s,e)char**s;{s=s<e?&f(&s[1])[*s]:0;}

-7 bytes thanks to @S.S. Anne
-5 bytes thanks to @Bubbler

Takes for input start and end pointers. It uses the fact that the address of &a[b] equals a+b. Other than that, even I am a bit confused as to how this works.

Try it online!

Improve this answer
\$\endgroup\$
11
  • \$\begingroup\$ Nicely done, but fails on multiple test cases, like 0, 3, 0 and 7, 0, 7 and 0, 9, 10. \$\endgroup\$
    – S.S. Anne
    Mar 22, 2020 at 23:50
  • \$\begingroup\$ You're right, let me see if I can fix that... \$\endgroup\$
    – dingledooper
    Mar 22, 2020 at 23:58
  • 1
    \$\begingroup\$ Nice. 45 bytes using return hack. \$\endgroup\$
    – S.S. Anne
    Mar 23, 2020 at 0:16
  • 1
    \$\begingroup\$ 43 bytes using the brackets to avoid parentheses. \$\endgroup\$
    – S.S. Anne
    Mar 23, 2020 at 15:34
  • 1
    \$\begingroup\$ 38 bytes with even more pointer abuse (and 64-bit ints, because TIO runs on a 64-bit machine.) \$\endgroup\$
    – Bubbler
    Mar 24, 2020 at 0:11
5
\$\begingroup\$

Japt, 1 byte

Trivial challenges get trivial solutions!

x

Try it

Improve this answer
\$\endgroup\$
0
5
\$\begingroup\$

Python 2/Python 3, 3 bytes

sum

Try it online (Py 3)! or Try it online (Py 2)!

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Also works in Haskell, and many other languages I'm sure. \$\endgroup\$
    – 79037662
    Mar 22, 2020 at 23:03
4
\$\begingroup\$

GERMAN, 141 bytes

EINGABESCHLEIFENANFANGSUBTRAKTIONRECHTSEINGABESCHLEIFENANFANGSUBTRAKTIONRECHTSADDITIONLINKSSCHLEIFENENDELINKSSCHLEIFENENDERECHTSRECHTSAUSGABE
Improve this answer
\$\endgroup\$
2
  • 11
    \$\begingroup\$ i'm disappointed this is just another brainfuck derivative rather than some complex combination of german words \$\endgroup\$
    – Jo King ♦
    Mar 23, 2020 at 0:22
  • \$\begingroup\$ @JoKing I am sorry to disappoint you. Unfortunately, programming languages not based on English are quite rare ... \$\endgroup\$
    – Jonathan Frech
    Mar 23, 2020 at 1:52
3
\$\begingroup\$

C (gcc), 94 bytes

x,c;n(a,b){for(;b;b=x*2)x=a&b,a^=b;x=a;}f(a,t)int*a;{for(c=1;c<t;c=n(c,1))*a=n(*a,a[c]);c=*a;}

A non-trivial golfed reference implementation.

I realized I had worded myself out of an answer when I couldn't even use + or - for a counter variable.

Try it online!

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Bash + GNU utilities, 57 bytes

printf %.f $(bc -l<<<"99*l(e(`sed 's@ @/99)*e(@g'`/99))")

Try it online!

Reads space-separated integers from stdin, and writes the output to stdout.

This applies the exponential function to each integer, multiplies the results, and then takes the natural logarithm of the product. I need to scale the input numbers (and then "unscale" the result) so as not to overflow the exponentials on some of the starred test examples (that's what the 99* and /99 are doing there).

Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Pyth, 1 byte

s

Try it online!

Explanation

s(Q)
 (Q) : Implicit evaluated input
s    : Sum the input
Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Mornington Crescent, 634 537 bytes

Take Northern Line to Bank
Take District Line to Parsons Green
Take District Line to Upminster
Take District Line to Temple
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Parsons Green
Take District Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Angel
Take Northern Line to Bank
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Try it online!

// initialize adder
Take Northern Line to Bank          // save input to Hammersmith
Take District Line to Parsons Green // get 0
Take District Line to Upminster     // set Upminster = 0

// set start of loop
Take District Line to Temple

// extract leading number
Take District Line to Hammersmith
Take District Line to Parsons Green

// add it to previous sum
Take District Line to Upminster     // accumulator = sum
                                    // Upminster = previous accumulator

// save sum in Upminster
Take District Line to Upminster

// get remaining string
Take District Line to Parsons Green

// check if it is equal to "" by translating the first char to its codepoint (0 if empty)
// we ride a few extra rounds here, adding 0s to the sum
Take District Line to Bank          // save string and 
                                    // get string of previous round
Take Northern Line to Charing Cross // swap accumulator with Charing Cross
                                    // and get codepoint of previous values' 
                                    // first char (that's from two rounds ago)
                                    // or 0 if empty

// if string is not empty (meaning, accumulator is non-zero), repeat
Take Northern Line to Angel

// else read sum
Take Northern Line to Bank          // get empty string
Take District Line to Upminster     // swap with Upminster

// and go home, outputting the number
Take District Line to Bank          // change lines, swapping data with Bank
Take Circle Line to Bank            // swap back
Take Northern Line to Mornington Crescent // go home
Improve this answer
\$\endgroup\$
3
\$\begingroup\$

Mornington Crescent, 1267 bytes

Try it online!

Poorly golfed, may have to have another attempt tomorrow.

Take Northern Line to Bank
Take Northern Line to Euston
Take Victoria Line to Seven Sisters
Take Victoria Line to Victoria
Take Circle Line to Victoria
Take Circle Line to Bank
Take District Line to Parsons Green
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Parsons Green
Take District Line to Upminster
Take District Line to Upney
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Moorgate
Take Circle Line to Temple
Take Circle Line to Moorgate
Take Circle Line to Bank
Take District Line to Parsons Green
Take District Line to Upney
Take District Line to Upminster
Take District Line to Upney
Take District Line to Upminster
Take District Line to Upney
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Moorgate
Take Circle Line to Hammersmith
Take Circle Line to Embankment
Take Northern Line to Charing Cross
Take Northern Line to Angel
Take Northern Line to Bank
Take District Line to Upney
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent
Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ I realized today that my past self was smarter and that my "better" solution is wrong -- it misses the edge case 0, which causes the program to terminate prematurely in the case of an input such as 3 0 4 1. Reverted, and see Dorian's Mornington Crescent answer as well for an improvement on how I handled this originally. \$\endgroup\$
    – Cloudy7
    Apr 26 at 3:13
2
\$\begingroup\$

Jelly, 1 byte

S

A built-in monadic atom which given a list yields the sum.

Try it online!

No built-in, 2 bytes:

ḅ1

Converts from base one to an integer.

Try it online!

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Keg, -hr, 2 bytes

÷⅀

Try it online!

The joys of not having implemented lists properly! Simply item split and summate. Essentially uses a sum function, so no imaginary points for me.

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Batch, 93 bytes

43 is the ASCII code for +:

@!! 2>nul||cmd/q/v/c%0&&exit/b
set c=cmd/c
set/pn=
%c%exit 43
%c%set/a !n: =%=exitcodeascii%!

Takes input via STDIN, delimited by space.

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

J, 4 bytes

1&#.

This was literally taken from here.

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

Haskell, 3 bytes

sum

Function that takes an argument as a list e.g. sum[1,2,3] and returns the sum of the list.

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

Brainetry, 143 bytes

a b c d e f
a b
a b c d e f
a b c d e f g h
a b c d e f g h
a b c d e

a b c d
a
a b c d e f g h i
a b c d e f
a b c d e f g h i

a b c d e f g

To try it online follow this repl.it link and paste the code in the btry/replit.btry file, then press the green "Run" button. Does I/O as ASCII codepoints.

The program above is the golfed version of this program:

Let me sum some numbers carefully.
Carefully enough
so that I do not use
the plus or minus signs, that'd be awful.
After I do this, oh so very carefully,
I just have to ...
Move the pointer
left and right for
a while.
This is the main gist of the whole program.
Of course this sounds somewhat uninteresting.
That is because you, my dear reader, lack depth.
(Is it "depth"?
Maybe that's not the correct English word...)
Improve this answer
\$\endgroup\$
3
  • 1
    \$\begingroup\$ These brainerty poems are always very interesting. \$\endgroup\$
    – The Fifth Marshal
    Jun 18, 2020 at 1:42
  • \$\begingroup\$ Do you need the blank lines in the golfed program? \$\endgroup\$
    – The Fifth Marshal
    Jun 18, 2020 at 3:04
  • \$\begingroup\$ @pppery not sure if you are just making fun or if you really think they are funny. Yes, the blank lines are needed. In Brainetry a blank line moves the pointer to the left edge of the tape, cf. this quick reference table \$\endgroup\$
    – RGS
    Jun 18, 2020 at 8:06
2
\$\begingroup\$

Pip, 4 bytes

_MSg

Try it online!

MS maps a function to an iterable and sums its results.

_ is the identity function.

g is the list of command line args.

Improve this answer
\$\endgroup\$
2
\$\begingroup\$

Python 3, 62/61 bytes

Without relying on sum in other functions.

def f(i,x=0):
	for y in i:
		while y:x,y=x^y,(x&y)*2
	return x

Can be shortened to 61 by removing the function definition (-13), replacing in i: with in eval(input()): (+12) and print instead of return at the end (+0).

Try it online!

Improve this answer
\$\endgroup\$
0
2
\$\begingroup\$

Python, 3 bytes

sum

Built in function which does the job

Try it online

With no built-in, 36 bytes in Python 2:

-3 thanks to ovs!

lambda a:eval(`a`.replace(*',\x2b'))

Try it online!

Note: a single value may be represented as a singleton list (meta)

Improve this answer
\$\endgroup\$
3
  • \$\begingroup\$ '\x2b' is one bytes shorter than chr(43). Then replace(*',\x2b') is another two bytes shorter. \$\endgroup\$
    – ovs
    Apr 20, 2020 at 12:52
  • \$\begingroup\$ @ovs - very nice, thank you! \$\endgroup\$
    – Jonathan Allan
    Apr 20, 2020 at 21:15
  • 2
    \$\begingroup\$ The built-in function also works in other versions. \$\endgroup\$
    – Hippopotomonstrosesquipedalian
    May 3 at 12:55
1
\$\begingroup\$

05AB1E, 1 bytes

O

Input as a list.

Try it online or verify all test cases.

Slightly less boring:

1β

Try it online or verify all test cases.

Explanation:

O   # Sum the (implicit) input-list
    # (and output the result implicitly)

1β  # Convert the (implicit) input-list to base-1
    # (and output the result implicitly)
Improve this answer
\$\endgroup\$
1
\$\begingroup\$

Racket, 133 bytes

(define(f a[s 0])(if(null? a)s(let([c(car a)])(if(= 0 c)(f(cdr a)s)(f(cons((if(> 0 c)add1 sub1)c)(cdr a))((if(> 0 c)sub1 add1)s))))))

Try it online!

Well...

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

perl -ple, 18 bytes

s/ /\x2b/g;$_=eval

Try it online!

Reads a space separated list of numbers from STDIN, writes the sum to STDOUT.

perl -MList::Util=sum -alpe, 8 bytes

$_=sum@F

Try it online!

Improve this answer
\$\endgroup\$
1
\$\begingroup\$

PowerShell, 60 24 bytes

$args-join[char]0x2b|iex

Try it online!

-36 bytes thanks to @mazzy

Improve this answer
\$\endgroup\$
2
  • \$\begingroup\$ you can to save some bytes Try it online! \$\endgroup\$
    – mazzy
    Mar 23, 2020 at 14:15
  • \$\begingroup\$ @mazzy much thanks! \$\endgroup\$
    – Wasif
    Mar 23, 2020 at 15:41
1
\$\begingroup\$

Haskell, 3 Bytes

sum

calculates the sum of a list

Improve this answer
\$\endgroup\$
2
  • 1
    \$\begingroup\$ This answer was already posted here \$\endgroup\$
    – RGS
    Jun 18, 2020 at 0:58
  • \$\begingroup\$ Duplicate answers aren't invalid, but users are encouraged to check for existing answers before posting \$\endgroup\$
    – Jo King ♦
    Sep 30, 2020 at 2:19
1
\$\begingroup\$

C++ (gcc), 83, 110 bytes

#include <iostream>
int n,x,c;int f(int i){while(i){c=n&i;n^=i;i=c<<1;}if(std::cin>>x)f(x);else std::cout<<n;}

Try it online!

Explanation: Reads in integer inputs and preforms bit-wise addition.

I tried to simplify the carry step like this but it gave me a negative result.

Improve this answer
\$\endgroup\$
4
  • \$\begingroup\$ You have to have #include <iostream> and using namespace std; if you're going to use cout and cin. Once you fix that I can suggest some improvements. \$\endgroup\$
    – S.S. Anne
    Apr 19, 2020 at 13:31
  • \$\begingroup\$ std:: is, in fact, not only much better, but also shorter here. !=0 in the while condition can be removed. \$\endgroup\$
    – the default.
    Apr 19, 2020 at 15:59
  • 1
    \$\begingroup\$ 101 bytes \$\endgroup\$
    – ceilingcat
    Apr 22, 2020 at 15:43
  • \$\begingroup\$ You don't need the space between #include and <iostream> \$\endgroup\$
    – mousetail
    Apr 26 at 6:57
1
\$\begingroup\$

Java 8, 35 bytes

x->x.stream().mapToInt(x->x).sum()

Takes a List of Integers.

Improve this answer
\$\endgroup\$
1
  • \$\begingroup\$ Nice Java solution :) But i think there are two problems : 1) It doesn't compile because there is a naming conflict between the outer x and the x inside the map. 2) Because OP explicitly disallowed usage of the character - in the whole code, sadly that should include the Java lambda arrow -> which contains a - :( \$\endgroup\$
    – Fhuvi
    Apr 24 at 9:30
1
2

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge that you have read and understand our privacy policy and code of conduct.

Not the answer you're looking for? Browse other questions tagged or ask your own question.