# Sum of all integers from 1 to n

I'm honestly surprised that this hasn't been done already. If you can find an existing thread, by all means mark this as a duplicate or let me know.

# Input

Your input is in the form of any positive integer greater than or equal to 1.

# Output

You must output the sum of all integers between and including 1 and the number input.

# Example

In: 5
1+2+3+4+5 = 15
Out: 15

OEIS A000217 — Triangular numbers: a(n) = binomial(n+1,2) = n(n+1)/2 = 0 + 1 + 2 + ... + n.

Run the code snippet below to view a leaderboard for this question's answers. (Thanks to programmer5000 and steenbergh for suggesting this, and Martin Ender for creating it.)

• Closely related – FryAmTheEggman Jul 18 '17 at 20:36
• @FryAmTheEggman Sorry - had a bit of a brain fart there. I see what you mean. – GarethPW Jul 18 '17 at 20:45
• @Aaron you got ninja'd by Husk, which was just posted with a 1 byte solution – Skidsdev Jul 18 '17 at 21:35
• I suggest a stack snippet. – programmer5000 Jul 19 '17 at 11:42
• – Jerry Jeremiah Jul 27 '17 at 12:20

# Pyth, 2 bytes

sS

Try it online! Implicit input. S is 1-indexed range, and s is the sum.

• Finally, Pyth(on) code sounds like a snake. – totallyhuman Jul 18 '17 at 21:15
• This is the perfect challenge for Pyth... – Mr. Xcoder Jul 18 '17 at 22:09
• I was going to answer this, but I guess not – Stan Strum Sep 7 '17 at 3:41

# Husk, 1 byte

Σ

Try it online!

Builtin! Σ in Husk is usually used to get the sum of all elements of a list, but when applied to a number it returns exactly n*(n+1)/2.

• Out of curiosity, does this occur because the number is cast to a range and then summed, or is this actually hardcoded? – FryAmTheEggman Jul 18 '17 at 21:33
• @FryAmTheEggman this is actually hardcoded, and is similar to the behavior of another builtin, Π, which can compute the product of all elements of a list or the factorial of a single number – Leo Jul 18 '17 at 21:37
• Σ is a two byte unicode character on my machine. I guess you use code page 1253? msdn.microsoft.com/en-us/library/cc195055.aspx – gmatht Jul 19 '17 at 2:32
• @gmatht Husk's code page – Jonathan Allan Jul 19 '17 at 3:02

# Piet, 161 bytes / 16 codels

You can interpret it with this Piet interpreter or upload the image on this website and run it there. Not sure about the byte count, if I could encode it differently to reduce size.

Scaled up version of the source image:

### Explanation

The highlighted text shows the current stack (growing from left to right), assuming the user input is 5:

Input a number and push it onto stack

5

Duplicate this number on the stack

5 5

Push 1 (the size of the dark red area) onto stack

5 5 1

5 6

Multiply the top two numbers

30

The black area makes sure, that the cursor moves down right to the light green codel. That transition pushes 2 (the size of dark green) onto stack

30 2

Divide the second number on the stack by the first one

15

Pop and output the top number (interpreted as number)

[empty]

By inserting a white area, the transition is a nop, the black traps our cursor. This ends execution of the program.

Original file (far too small for here):

• We transitioned from an intelligible text (e.g. C) to unintelligible text (e.g. Jelly) to images... What next? :P – frarugi87 Jul 24 '17 at 7:32
• +1 I haven't actually seen a Piet answer with an explanation before – MilkyWay90 Apr 1 '19 at 23:01

# Brain-Flak, 16 bytes

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

Try it online!

This is one of the few things that brain-flak is really good at.

Since this is one of the simplest things you can do in brain-flak and it has a lot of visibility, here's a detailed explanation:

# Push the sum of all of this code. In brain-flak, every snippet also returns a
# value, and all values inside the same brackets are summed
(
# Loop and accumulate. Initially, this snippet return 0, but each time the
# loop runs, the value of the code inside the loop is added to the result.
{
# Push (and also return)...
(
# The value on top of the stack
{}

# Plus the negative of...
[
# 1
()
]

# The previous code pushes n-1 on to the stack and returns the value n-1
)

# 1
# This code has no side effect, it just returns the value 1 each loop.
# This effectively adds 1 to the accumulator
()

# The loop will end once the value on top of the stack is 0
}

# Pop the zero off, which will also add 0 to the current value
{}

# After the sum is pushed, the entire stack (which only contains the sum)
# will be implicitly printed.
)

# Oasis, 3 bytes

n+0

Try it online!

## How it works

n+0
0    a(0)=0
n+     a(n)=n+a(n-1)
• And here I was, all of my life thinking that n+0 is n... – Wojowu Jul 19 '17 at 7:22

## JavaScript (ES6), 10 bytes

n=>n*++n/2

### Example

let f =

n=>n*++n/2

console.log(f(5))

• n*-~n/2 also works, but only for n < 2**31 – Patrick Roberts Dec 3 '17 at 18:53

#(#+1)/2&

(#^2+#)/2&

Tr@Range@#&

i~Sum~{i,#}&

(by @user71546)

1/2/Beta[#,2]&

Tr[#&~Array~#]&

Binomial[#+1,2]&

(by @Not a tree)

⌊(2#+1)^2/8⌋&

# Mathematica, 18 bytes

PolygonalNumber@#&

# Mathematica, 19 bytes

#+#2&~Fold~Range@#&

# Mathematica, 20 bytes

(by @Not a tree)

f@0=0;f@i_:=i+f[i-1]
• It seems a shame to skip 13, 14 and 17… – Not a tree Jul 19 '17 at 0:48
• It seems like a next challenge....or at least help me to complete the list. – ZaMoC Jul 19 '17 at 0:51
• I still don't have anything for 13 or 14 bytes (apart from just un-golfing your shorter answers), but here are another 26 with larger byte-counts. – Not a tree Jul 19 '17 at 7:16
• @MarkS. on 10.4 works fine – ZaMoC Jul 25 '17 at 10:56
• @Notatree For your list, here is a candidate for 35: Array[Boole[#2>=#]&,{#,#}]~Total~2& – Mark S. Aug 12 '17 at 5:07

# x86_64 machine language (Linux), 9 8 bytes

0:   8d 47 01                lea    0x1(%rdi),%eax
3:   f7 ef                   imul   %edi
5:   d1 e8                   shr    %eax
7:   c3                      retq

To Try it online! compile and run the following C program.

#include<stdio.h>
const char f[]="\x8d\x47\x01\xf7\xef\xd1\xe8\xc3";
int main(){
for( int i = 1; i<=10; i++ ) {
printf( "%d %d\n", i, ((int(*)())f)(i) );
}
}

Thanks to @CodyGray and @Peter for -1.

• You should probably use shr instead of sar, to treat your output as unsigned (no change in code size). (Spotted by @CodyGray and pointed out in his 7-byte add+loop answer). – Peter Cordes Jul 22 '17 at 8:36
• This looks optimal for performance in an implementation of the closed-form formula, but you can save a byte by using the one-operand form of mul %edi or imul %edi (each 2B) instead of the 3B two-operand form. It clobbers EDX with the high-half result, but that's fine. Multi-operand imul was introduced later than the one-operand form, and has a 2-byte opcode with a 0F escape byte. Any of the three options will always produce the same result in eax, it's only the high half that depends on signed vs. unsigned. – Peter Cordes Jul 22 '17 at 8:36

# Python 2, 24 16 bytes

-8 bytes thanks to FryAmTheEggman.

lambda n:n*-~n/2

Try it online!

# C# (.NET Core), 10 bytes

n=>n++*n/2

Try it online!

• Polyglots with JS. – Makonede Apr 19 at 20:41

n->n++*n/2

Try it online!

# Octave, 22 19 bytes

Because arithmetic operations are boring...

@(n)nnz(triu(e(n)))

Try it online!

### Explanation

Given n, this creates an n×n matrix with all entries equal to the number e; makes entries below the diagonal zero; and outputs the number of nonzero values.

# Jelly, 2 bytes

RS

Try it online!

## Explanation

RS

implicit input
S  sum of the...
R   inclusive range [1..input]
implicit output

## Gauss sum, 3 bytes

‘×H

### Explanation

‘×H

implicit input
H  half of the quantity of...
‘    input + 1...
×   times input
implicit output
• This also works in Anyfix :P (not on TIO) – hyper-neutrino Jul 18 '17 at 21:08

# Java (OpenJDK 8), 10 bytes

a->a++*a/2

Try it online!

Took a moment to golf down from n->n*(n+1)/2 because I'm slow.

But this isn't a real Java answer. It's definitely not verbose enough.

import java.util.stream.*;
a->IntStream.range(1,a+1).sum()

Not bad, but we can do better.

import java.util.stream.*;
(Integer a)->Stream.iterate(1,(Integer b)->Math.incrementExact(b)).limit(a).reduce(0,Integer::sum)

I love Java.

• If you want it to be even more verbose why use a lambda!? :P – TheLethalCoder Jul 19 '17 at 12:36
• I was aiming for verbose lambdas, I could write a full program if I wanted to be particularly eloquent :P – Xanderhall Jul 19 '17 at 12:38
• The exact same solution was already posted – Winter Jul 19 '17 at 18:56
• I must have missed it, but in any case, I tend to not look at the contents of other answers. I prefer to write my own golf. – Xanderhall Jul 20 '17 at 11:21

# APL, 3 bytes

+/⍳

Try it online!

+/ - sum (reduce +), - range.

• This depends on the indexing. If indexing is set to 0, then you'd need an additional 2 bytes 1+ – Werner Jul 18 '17 at 21:27
• @Werner indexing is default 1 so I didn't specify. its common here to specify only when using ⎕IO←0 (and it does not included in byte count) – Uriel Jul 18 '17 at 21:29

This is the shortest (I thinkthought):

f n=sum[1..n]

Try it online!

### Direct, 17 13 bytes

f n=n*(n+1)/2

Thanks @WheatWizard for -4 bytes!

Try it online!

### Pointfree direct, 15 bytes

(*)=<<(/2).(+1)

Thanks @nimi for the idea!

Try it online!

sum.enumFromTo 1

Try it online!

### Recursively, 22 18 bytes

f 0=0;f n=n+f(n-1)

Thanks @maple_shaft for the idea & @Laikoni for golfing it!

Try it online!

### Standard fold, 19 bytes

f n=foldr(+)0[1..n]

Try it online!

# Starry, 27 22 bytes

5 bytes saved thanks to @miles!

, + +  **       +   *.

Try it online!

### Explanation

,             Read number (n) from STDIN and push it to the stack
+            Duplicate top of the stack
+            Duplicate top of the stack
*           Pop two numbers and push their product (n*n)
*             Pop two numbers and push their sum (n+n*n)
+      Push 2
*          Pop two numbers and push their division ((n+n*n)/2)
.             Pop a number and print it to STDOUT
• – miles Jul 18 '17 at 23:20
• @miles Thanks! Very good idea! – Luis Mendo Jul 18 '17 at 23:53

LO

Try it online!

# How it works

#input enters stack implicitly
L    #pop a, push list [1 .. a]
O   #sum of the list
#implicit output

>¹*;

Try it online!

# How it works

>       #input + 1
¹*     #get original input & multiply
;    #divide by two
• ÝO also works and means hello. – Magic Octopus Urn Jul 19 '17 at 15:01
• L0 and behold.. – dylnan Dec 11 '17 at 16:16
• The Gaussian sum can be shortened by one byte without ¹, as implicit input can be reused. – Makonede Apr 19 at 20:37

# Taxi, 687 bytes

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l 2 r.[a]Pickup a passenger going to Addition Alley.Pickup a passenger going to The Underground.Go to Zoom Zoom:n.Go to Addition Alley:w 1 l 1 r.Pickup a passenger going to Addition Alley.Go to The Underground:n 1 r 1 r.Switch to plan "z" if no one is waiting.Pickup a passenger going to Cyclone.Go to Cyclone:n 3 l 2 l.Switch to plan "a".[z]Go to Addition Alley:n 3 l 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:n 1 r 1 r.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.

Try it online!

[ n = STDIN ]
Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left 2nd right.

[ for (i=n;i>1;i--) { T+=i } ]
[a]
Pickup a passenger going to Addition Alley.
Pickup a passenger going to The Underground.
Go to Zoom Zoom: north.
Go to Addition Alley: west 1st left 1st right.
Pickup a passenger going to Addition Alley.
Go to The Underground: north 1st right 1st right.
Switch to plan "z" if no one is waiting.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 3rd left 2nd left.
Switch to plan "a".

[ print(T) ]
[z]
Go to Addition Alley: north 3rd left 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: north 1st right 1st right.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st left 1st right.

It's 22.6% less bytes to loop than it is to use x*(x+1)/2

# MATL, 2 bytes

:s

Try it online!

Not happy smiley.

• Damn it, finally a challenge I could easily answer in MATL, but you beat me to it :( – Lui Jul 19 '17 at 6:27

n->n*-~n/2

Try it online!

n->sum(1:n)

Try it online!

# Brainfuck, 24 Bytes.

I/O is handled as bytes.

,[[->+>+<<]>[-<+>]<-]>>.

## Explained

,[[->+>+<<]>[-<+>]<-]>>.
,                           # Read a byte from STDIN
[                  ]       # Main loop, counting down all values from n to 1
[->+>+<<]                 # Copy the i value to *i+1 and *i+2
>[-<+>]          # Move *i+1 back to i
<-        # Move back to i, lower it by one. Because *i+2 is never reset, each iteration adds the value of i to it.
>>.    # Output the value of *i+2
• It's pretty cool that Brainfuck is able to beat some higher-level languages in this challenge. – GarethPW Jul 19 '17 at 10:49
• Is that legit for me to add an answer in Lenguage (just for fun) using your code? @ATaco – V. Courtois Jul 26 '17 at 12:44
• I don't think so, as it would be the same code, just encoded different. @V.Courtois – ATaco Jul 26 '17 at 13:07
• @ATaco Ahh you're right. – V. Courtois Jul 26 '17 at 13:19

d1+*2/p

OR

d2^+2/p

OR

dd*+2/p

Try it online!

# ,,,, 6 bytes

:1+×2÷

## Explanation

:1+×2÷

:       ### duplicate
×    ### multiply
2÷  ### divide by 2

If I implement range any time soon...

# Retina, 13 bytes

.+
$* 1$`1
1

Try it online! Explanation: The first and last stages are just unary ⇔ decimal conversion. The middle stage replaces each 1 with the number of 1s to its left plus another 1 for the 1 itself, thus counting from 1 to n, summing the values implicitly.

# ><>, 7+3 = 10 bytes

Calculates n(n+1)/2.
3 bytes added for the -v flag

:1+2,*n

Try it online!

Or if input can be taken as a character code:

# ><>, 9 bytes

i:1+2,*n;

Try it online!

• Using the other math-approach ((n^2+n)/2) is also 7 bytes: ::*+2,n – steenbergh Jul 19 '17 at 8:18

# PHP, 19 bytes

<?=$argn*-~$argn/2;
<?=$argn/2*++$argn;
<?=$argn*++$argn/2; # this one fails

using builtins, 29 bytes:

<?=array_sum(range(1,$argn)); loop, 31 bytes: while($argn)$s+=$argn--;echo$s; • I guess a for too: for(;$argn;$s+=$argn--);echo$s; – Progrock Oct 13 '19 at 17:12 # Triangular, 10 bytes$\:_%i/2*<

Ungolfed:

$\ : _ % i / 2 * < Try it online! The code, without directionals, is read as$:i*2_%.

• \$ reads an integer x, stack contains {x}.
• : duplicates it, stack contains {x,x}.
• i increments the top of stack, stack contains {x,x+1}.
• * multiplies the top two stack values, stack contains {x*(x+1)}.
• 2 pushes 2 to the stack, stack contains {x*(x+1),2}.
• _ divides the top two stack values, stack contains {x*(x+1)/2}.
• % prints the top of stack, the equation x*(x+1)/2.

Idea thanks to caird, who asked me to post.

*,)2I://O@

....I:)*2,O@

Try it online!

# Explanation

Expanded onto a cube, the code looks like this:

* ,
) 2
I : / / O @ . .
. . . . . . . .
. .
. .

The instruction pointer (IP) starts at the I, moving east. It continues moving east until it comes across the / mirror, which reflects it north. When the IP reaches the top of the code, it wraps around to the last . on the third line, moving south. Then it wraps to the penultimate . on the last line, moving north. Then it reaches the / mirror again, which reflects it east, only for the next / to reflect it north again. This time, the IP wraps to the penultimate . on the third line, and then the last . on the last line.

The instructions are executed in the following order.

I:)*2,O@ # Explanation
I        # Take input as an integer and push it to the stack
:       # Duplicate the input
)      # Increment one of the inputs
*     # Multiply the input by input+1
2    # Push 2 to the stack
,   # Integer devide the multiplication result by 2
O  # Output the result
@ # End program