Sum of all integers from 1 to n

Question

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.

Leaderboard

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.)

var QUESTION_ID=133109,OVERRIDE_USER=69148;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px} /* font fix */ body {font-family: Arial,"Helvetica Neue",Helvetica,sans-serif;} /* #language-list x-pos fix */ #answer-list {margin-right: 200px;}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Answer 1

><>, 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!

Answer 2

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;

Answer 3

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.}

Answer 4

Cubix, 12 10 bytes

*,)2I://O@

Initial version

....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

Answer 5

x86-64 Machine Code, 7 bytes

31 C0
01 C8
E2 FC
C3  

The above bytes define a function that accepts a single parameter, n, and returns a value containing the sum of all integers from 1 to n.

It is written to the Microsoft x64 calling convention, which passes the parameter in the ECX register. The return value is left in EAX, like all x86/x86-64 calling conventions.

Ungolfed assembly mnemonics:

       xor  eax, eax    ; zero out EAX
Next:  add  eax, ecx    ; add ECX to EAX
       loop Next        ; decrement ECX by 1, and loop as long as ECX != 0
       ret              ; return, with result in EAX

Try it online!
_{(The C function call there is annotated with an attribute that causes GCC to call it using the Microsoft calling convention that my assembly code uses. If TIO had provided MSVC, this wouldn't be necessary.)}

---

By the unusual standards of code golf, you see that this iterative looping approach is preferable to approaches that use the more sane mathematical formula (n(n+1) / 2), even though it is obviously vastly less efficient in terms of run-time speed.

Using number theory, ceilingcat's implementation can still be beat by one byte. Each of these instructions are essential, but there is a slightly shorter encoding for IMUL that uses EAX implicitly as a destination operand (actually, it uses EDX:EAX, but we can just ignore the upper 32 bits of the result). This is only 2 bytes to encode, down from 3.

LEA takes three bytes as well, but there's really no way around that because we need to increment while preserving the original value. If we did a MOV to make a copy, then INC, we'd be at 4 bytes. (In x86-32, where INC is only 1 byte, we'd be at the same 3 bytes as LEA.)

The final right-shift is necessary to divide the result in half, and is certainly more compact (and more efficient) than a multiplication. However, the code should really be using shr instead of sar, since it's assuming that the input value, n, is an unsigned integer. (That assumption is valid according to the rules, of course, but if you know that the input is unsigned, then you shouldn't be doing a signed arithmetic shift, as the upper bit being set in a large unsigned value will cause the result to be incorrect.)

8D 41 01                lea    eax, [rcx+1]
F7 E9                   imul   ecx
D1 E8                   shr    eax, 1
C3                      ret

Now only 8 bytes (thanks to Peter Cordes). Still, 8 > 7.

Answer 6

ArnoldC, 310 bytes

Removes unnecessary variable assignments from Courtois' solution and replaces them with GET TO THE CHOPPER and some arithmetic operations.

IT'S SHOWTIME
HEY CHRISTMAS TREE n
YOU SET US UP 0
GET YOUR ASS TO MARS n
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
GET TO THE CHOPPER n
HERE IS MY INVITATION n
GET UP 1
YOU'RE FIRED n
HE HAD TO SPLIT 2
ENOUGH TALK
TALK TO THE HAND n
YOU HAVE BEEN TERMINATED

Who doesn't like some good Arnold Schwarzenegger one liners :)

Try it online!

Answer 7

Python 2, 16 bytes

lambda n:-~n*n/2

Try it online!

Answer 8

TI-Basic, 6 bytes

sum(randIntNoRep(1,Ans

Alternate solutions:

mean({AnsAns,Ans   6 bytes credits to @user1812
.5Ans(Ans+1        7 bytes
.5(AnsAns+Ans      7 bytes
Σ(I,I,1,Ans        9 bytes
sum(seq(I,I,1,Ans  9 bytes

Answer 9

Hexagony, 14 bytes

?'+\.*:){=/\!2

Try it online! or Try it in a visual editor!

Expanded out, this is:

  ? ' +
 \ . * :
) { = / \
 ! 2 . .
  . . .

It took quite a bit of effort to get from a trivial 15 byte modification of Underslash's answer (using a char literal for 2), to get to 14 bytes. We save that one byte by managing to reuse all of '{= at the cost of an extra control flow instruction, as well as by terminating through an error of division by zero. There's still one no-op in the middle of this, so perhaps 13 is possible (but unlikely)?

Expanding it out by following the control flow, we find this:

?'+){=*'2{+*=2?*:!2)+*=2?*:

Removing all the extra stuff that are basically no-ops or are there to force a specific path of execution, we get:

?'+){=*'2{=:!=:
?                 Get the input
 '+               Duplicate it to an adjacent edge
   )              Increment it
    {=*           Multiply the original by the incremented one
       '2         Place 2 in an adjacent cell
         {=:      Divide the result by 2
            !     And print
             =:   Divide by zero

Answer 10

Ohm, 2 bytes

@Σ

Try it online!

Explanation

@Σ

    implicit input
@   inclusive range [1..input]
 Σ  sum
    implicit output

Answer 11

PowerShell, 22 18 bytes

param($n)$n*++$n/2

Try it online!

Saved 4 bytes thanks to FryAmTheEggman. Uses Gauss' formula. Ho-hum.

Answer 12

WendyScript, 17 bytes

<<f=>(x)x*(x+1)/2

f(100) // => 5050

Try it online!

Answer 13

cQuents, 2 bytes

;$

This is the type of question that cQuents was designed for, and the type of question I implemented the ; mode for. Take that, Oasis!

Try it online!

Explanation

;    Mode: Sum (output sum of sequence up to input)
 $   Each item in the sequence is its (1-based) index

Answer 14

Brachylog, 2 bytes

⟦+

Try it online!

Explanation

⟦      Range: [0, …, Input]
 +     Sum:   0 + … + Input

Answer 15

Lean Mean Bean Machine, 38 32 bytes

-5 bytes thanks to Roman Gräf
-1 byte from changing LMBM's division peg from £ to ,

 O O
 i 2
 o
  )/
  ,
  /
 /
*
u

Explanation

Each O spawns a marble at program start. The first marble reads input and has it's value set to it, the 2nd has it's value set to 1, and the 3rd has it's value set to 2.

The n-marble is then duplicated, one copy falls all the way to a multiplication operator, where it will be held for a 2nd marble, the other falls into a subtraction operator, which the 1-marble then falls into after it.

This new n-1-marble then falls into a division operator (,), and the 2-marble falls in right after it.

This (n-1)/2-marble then falls into the multiplication operator, and the final n*(n-1)/2 marble falls into a u peg, where its value is printed, and the marble is destroyed.

Answer 16

Bash, 26, 19 bytes

echo $[($1+1)*$1/2]

Try it online!

19 bytes for the code, thanks to rexkogitans.

Answer 17

8th, 21 12 bytes

Saved 9 bytes thanks to FryAmTheEggman

dup 1+ * 2 /

Usage and output

ok> : sum dup n:1+ * 2 / ;

ok> 5 sum .
15

Answer 18

TI-BASIC, 6 bytes

Beating Casio-basic by 3 bytes :) 6 byte version thanks to PT_ from cemetech (https://www.cemetech.net/forum/profile.php?mode=viewprofile&u=10064)

mean({N²,N

Two other, 7 byte, versions:

.5N(N+1 

.5(N²+N

Answer 19

brainfuck, 24 bytes

Input number in base255(ASCII), use bigger cells for larger numbers, outputs also in base255.

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

Try it online!

For bigger cells.

    ,[         Get input in base 255 mod 2^bit
         [ >+  Copy it left(to preserve index) 
           >+  and left left to accumulate the sum
     <<- ]     decrement index to break loop
         >     Move to the first copy, index'in
         [-<+>]Move it back, restoring the index
  <- ]         Decrement index, let function run again until 0
    >>. Print sum 

Answer 20

Symbolic Python, 35 33 18 16 bytes

_=-~_*_/-~(_==_)

Try it online!

Uses the direct formula for triangle numbers, (n+1)(n/2):

_=                  # Set output to
  -~_               #   (n+1)
     *_             #   *n
       /-~(_==_)    #   /2

Answer 21

Ruby, 29 17 18 14 12 bytes

->n{n*-~n/2}

Execution:

->n{n*-~n/2}.call(5)

Gets The Value of the sum of 1 through 5

Try It Out!

People Who Have Saved Me A Few Bytes:

Saved 12 Bytes - DJMcMayhem

Saved 6 Bytes - FryAmTheEggman

Unsaved 3 Bytes (But Added Variable Handling) - Value Ink

Fixed A Misunderstanding, Saving me 8 Bytes - Value Ink

Saved 2 Bytes - G B

Many Thanks!

Answer 22

Alchemist, 40 bytes

0x+_->a+Out_I
0_+0x+a->x
x+a->_+x
x+0a->

Outputs in unary, try it online or try it with automatic conversion to decimal!

Explanation

We'll 3 types of atoms the \$\texttt{_}\$-, \$\texttt{x}\$- and \$\texttt{a}\$-atoms:

• \$\texttt{_}\$ initially is the input
• \$\texttt{x}\$ is to make sure the computation is deterministic
• \$\texttt{a}\$

# When there is no x-atom but still _ left, transform it to a and output I
0x + _ -> a + Out_I
# If there are no _- and x-atoms but still at least one a, we remove one a and add an x
0_ + 0x + a -> x
# If there is an x-atom, exchange all a-atoms for _-atoms
x + a -> _ + x
# Once we're done with that, remove the x-atom (this makes the first rule applicable again, creating a loop)
x + 0a ->

So essentially we transform each \$\texttt{_}\$ to \$\texttt{a}\$ while outputting an \$\texttt{I}\$, remove one \$\texttt{a}\$ and exchange them back to \$\texttt{_}\$, until there are no \$\texttt{a}\$-atoms and no rule is applicable anymore - terminating the progress of the universe.

Answer 23

tinylisp, 30 bytes

(d F(q((n)(i n(a n(F(s n 1)))0

Try it online!

Answer 24

Vyxal s, 1 byte

ɾ

Inclusive range of 1 to input, and s flag sums the stack.

Try it!

Answer 25

HP UserRPL, 5.5 bytes

The source, pretty-formatted and commented:

«
  'X' @function@
  DUP @variable@
  1 @start@
  4 ROLL @end, ...is programm input@
  SEQ @create-list@
  ΣLIST @sum list items, equiv: « + » STREAM@
»

When saved in the calculator, @comments@ and extra spaces are lost.
The source you'll retrieve on your computer, using ASCII should look like

\<< 'X' DUP 1 4 ROLL SEQ \SigmaLIST \>>

In calculator, programs are saved with some kind of tokenisation where DUP and ROLL aren't 3 bytes but only half each.

Answer 26

F# (.NET Core), ¹² 17 bytes

let s x=(x+1)*x/2

Try it online!

Answer 27

AArch64 machine code, 12 bytes

0:  9b000000  madd  x0, x0, x0, x0
4:  d341fc00  lsr   x0, x0, #1
8:  d65f03c0  ret

Equivalent to:

uint64_t f(uint64_t n) {
  n = (n * n) + n;
  n = n >> 1;
  return n;
}

To test it, compile and run this C code with a GCC compatible compiler on AArch64 hardware via a Linux distro, Termux, Windows ARM64, etc.

#include <inttypes.h>
#include <stdio.h>

static uint64_t (*const f)(uint32_t) = (const uint32_t[]) {
  0x9b000000, // madd x0, x0, x0, x0
  0xd341fc00, // lsr  x0, x0, #1
  0xd65f03c0, // ret
};

int main(void) {
  uint32_t n = 5;
  scanf("%" SCNu32, &n);
  printf("%" PRIu64 "\n", f(n));
}

Note that I limited it to 32-bit inputs in the test code, because it overflows on the multiply-add when n >= (1 << 32).

It should work even in big-endian mode :)

Answer 28

Positron, 27 bytes

Positron is a new practical language by @HyperNeutrino.

function{return$1*($1+1)/2}

Try it online!

Answer 29

Perl 6, 11 bytes

{[+] 1..$_}

Try it

{ } creates a lambda block with implicit parameter $_
1 .. $_ creates a Range object
[+] reduces it using the &infix:«+» operator.

(Rakudo actually calls the sum method on the Range object if you haven't lexically modified the &infix:«+» operator, and the sum method knows how to calculate the result without iterating through all of the values)

Answer 30

Element, 32 Bytes

_'1 z;0 t;[z~2:z;t~+t;z~1+z;]t~`

Try it online!

Probably can go shorter, but late now...