Sinceramente, estou surpreso que isso ainda não tenha sido feito. Se você puder encontrar um encadeamento existente, marque-o como duplicado ou me avise.

Entrada

Sua entrada está na forma de qualquer número inteiro positivo maior ou igual a 1.

Resultado

Você deve produzir a soma de todos os números inteiros entre 1 e inclusive 1 e a entrada de número.

Exemplo

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

OEIS A000217 - Números triangulares: a (n) = binomial (n + 1,2) = n (n + 1) / 2 = 0 + 1 + 2 + ... + n.

Entre os melhores

Execute o snippet de código abaixo para visualizar um cabeçalho das respostas desta pergunta. (Agradecemos a programmer5000 e steenbergh por sugerir isso e Martin Ender por criá-lo.)

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>

Pitão , 2 bytes

sS

Experimente online! Entrada implícita. Sé um intervalo indexado a 1 e sé a soma.

Casca , 1 byte

Σ

Experimente online!

Construídas em! Σem Husk geralmente é usado para obter a soma de todos os elementos de uma lista, mas quando aplicado a um número, ele retorna exatamente n*(n+1)/2.

Piet , 161 bytes / 16 codels

Você pode interpretá-lo com este intérprete Piet ou fazer upload da imagem neste site e executá-la lá. Não tenho certeza sobre a contagem de bytes, se eu pudesse codificá-lo de maneira diferente para reduzir o tamanho.

Versão ampliada da imagem de origem:

Explicação

O highlightedtexto mostra a pilha atual (crescendo da esquerda para a direita), assumindo que a entrada do usuário seja 5:

Insira um número e empurre-o para a pilha

5

Duplique esse número na pilha

5 5

Empurre 1 (o tamanho da área vermelha escura) na pilha

5 5 1

Adicione os dois primeiros números

5 6

Multiplique os dois principais números

30

A área preta garante que o cursor se desloque para a direita até o codel verde claro. Essa transição coloca 2 (do tamanho de verde escuro) na pilha

30 2

Divida o segundo número na pilha pelo primeiro

15

Abre e gera o número superior (interpretado como número)

[empty]

Ao inserir uma área branca, a transição é a nop, o preto intercepta nosso cursor. Isso termina a execução do programa.

Arquivo original (pequeno demais para aqui):

Flak cerebral , 16 bytes

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

Experimente online!

Essa é uma das poucas coisas nas quais o cérebro é realmente bom.

Como essa é uma das coisas mais simples que você pode fazer no cérebro e tem muita visibilidade, aqui está uma explicação detalhada :

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

Oásis , 3 bytes

n+0

Experimente online!

Como funciona

n+0
  0    a(0)=0
n+     a(n)=n+a(n-1)

Mathematica, 9 bytes

#(#+1)/2&

Mathematica, 10 bytes

(#^2+#)/2&

Mathematica, 11 bytes

Tr@Range@#&

Mathematica, 12 bytes

i~Sum~{i,#}&

Mathematica, 14 bytes

(por @ user71546)

1/2/Beta[#,2]&

Mathematica, 15 bytes

Tr[#&~Array~#]&

Mathematica, 16 bytes

Binomial[#+1,2]&

Mathematica, 17 bytes

(por @Not a tree)

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

Mathematica, 18 bytes

PolygonalNumber@#&

Mathematica, 19 bytes

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

Mathematica, 20 bytes

(por @Not a tree)

f@0=0;f@i_:=i+f[i-1]

JavaScript (ES6), 10 bytes

n=>n*++n/2

Exemplo

let f =

n=>n*++n/2

console.log(f(5))

linguagem de máquina x86_64 (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 

Para experimentá-lo online! compile e execute o seguinte programa C.

#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) );
  }
}

Obrigado a @CodyGray e @Peter por -1.

Python 2 , 24 16 bytes

-8 bytes graças a FryAmTheEggman.

lambda n:n*-~n/2

Experimente online!

C # (.NET Core) , 10 bytes

n=>n++*n/2

Experimente online!

Java (OpenJDK 8) , 10 bytes

n->n++*n/2

Experimente online!

Oitava , 22 19 bytes

Porque operações aritméticas são chatas ...

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

Experimente online!

Explicação

Dado n, isso cria uma matriz n× ncom todas as entradas iguais ao número e ; faz entradas abaixo do zero diagonal; e gera o número de valores diferentes de zero.

Gelatina , 2 bytes

RS

Experimente online!

Explicação

RS

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

Soma de Gauss, 3 bytes

‘×H

Explicação

‘×H

     implicit input
  H  half of the quantity of...
‘    input + 1...
 ×   times input
     implicit output

APL, 3 bytes

+/⍳

Experimente online!

+/- soma (redução +), ⍳- intervalo.

Haskell , 13 bytes

Este é o mais curto (eu acho que pensei):

f n=sum[1..n]

Experimente online!

Direto, 17 13 bytes

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

Obrigado @WheatWizard por -4bytes!

Experimente online!

Direto sem ponto, 15 bytes

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

Obrigado @nimi pela ideia!

Experimente online!

Via sem ponto sum, 16 bytes

sum.enumFromTo 1

Experimente online!

Recursivamente, 22 18 bytes

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

Obrigado @maple_shaft pela ideia e @Laikoni por jogarem!

Experimente online!

Padrão fold, 19 bytes

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

Experimente online!

Estrelado , 27 22 bytes

5 bytes salvos graças ao @miles !

, + +  **       +   *.

Experimente online!

Explicação

,             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

05AB1E , 2 bytes

LO

Experimente online!

Como funciona

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

Soma de Gauss, 4 bytes

>¹*;

Experimente online!

Como funciona

>       #input + 1
 ¹*     #get original input & multiply
   ;    #divide by two 

Java (OpenJDK 8) , 10 bytes

a->a++*a/2

Experimente online!

Demorou um momento para jogar golfe n->n*(n+1)/2porque sou lento.

Mas essa não é uma resposta Java real. Definitivamente, não é detalhado o suficiente.

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

Nada mal, mas podemos fazer melhor.

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

Eu amo Java.

Verifique , 5 bytes

:)*$p

O cheque não é nem um idioma de golfe, mas é melhor que o CJam!

Experimente online!

Explicação:

O número de entrada é colocado na pilha. :duplica para dar n, n. É então incrementado com ), dando n, n+1. *multiplica os dois juntos e depois $divide o resultado por 2. pimprime o resultado e o programa termina.

MATL , 2 bytes

:s

Experimente online!

Smiley não feliz.

Táxi , 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.

Experimente online!

Sem jogar golfe com comentários:

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

_{É 22,6% menos bytes de loop do que usar x*(x+1)/2}

Julia, 10 bytes

n->n*-~n/2

Experimente online!

11 bytes (funciona também em Julia 0.4)

n->sum(1:n)

Experimente online!

Brainfuck, 24 bytes.

A E / S é tratada como bytes.

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

Explicado

,[[->+>+<<]>[-<+>]<-]>>.
,                           # 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

,,,, 6 bytes

:1+×2÷

Explicação

:1+×2÷

:       ### duplicate
 1+     ### add 1
   ×    ### multiply
    2÷  ### divide by 2

Se eu implementar intervalo em breve ...

rΣ

Retina , 13 bytes

.+
$*
1
$`1
1

Experimente online! Explicação: O primeiro e o último estágio são apenas uma conversão decimal ary unária. O estágio intermediário substitui cada um 1pelo número de 1s à esquerda e outro 1por 1ele mesmo, contando desde1 de n, soma os valores implicitamente.

> <> , 7 + 3 = 10 bytes

Calcula n (n + 1) / 2 .
3 bytes adicionados ao sinalizador -v

:1+2,*n

Experimente online!

Ou se a entrada puder ser tomada como um código de caractere:

> <> , 9 bytes

i:1+2,*n;

Experimente online!

dc , 7 bytes

d1+*2/p

OU

d2^+2/p

OU

dd*+2/p

Experimente online!

PHP, 19 bytes

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

usando builtins, 29 bytes:

<?=array_sum(range(1,$argn));

loop, 31 bytes:

while($argn)$s+=$argn--;echo$s;

Cubix , 12 10 bytes

*,)2I://O@

Versão inicial

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

Experimente online!

Explicação

Expandido para um cubo, o código fica assim:

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

O ponteiro de instrução (IP) começa no I, movendo-se para o leste. Ele continua se movendo para o leste até encontrar o /espelho, que o reflete ao norte. Quando o IP alcança o topo do código, ele se aproxima do último .na terceira linha, movendo-se para o sul. Depois, chega ao penúltimo .na última linha, movendo-se para o norte. Em seguida, alcança o /espelho novamente, o que o reflete a leste, apenas para o próximo /a refletir novamente para o norte. Dessa vez, o IP passa para o penúltimo .na terceira linha e, em seguida, o último .na última linha.

As instruções são executadas na seguinte ordem.

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

Código da máquina x86-64, 7 bytes

31 C0
01 C8
E2 FC
C3  

Os bytes acima definem uma função que aceita um único parâmetro ne retorna um valor que contém a soma de todos os números inteiros de 1 a n.

Ele é gravado na convenção de chamada do Microsoft x64 , que passa o parâmetro no ECXregistro. O valor de retorno é deixado em EAX, como todas as convenções de chamada x86 / x86-64.

Mnemônicos de montagem não destruídos:

       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

Experimente online!
_{(A chamada de função C é anotada com um atributo que faz com que o GCC a chame usando a convenção de chamada da Microsoft que meu código de assembly usa. Se o TIO tivesse fornecido o MSVC, isso não seria necessário.)}

Pelos padrões incomuns do código golf, você vê que essa abordagem de loop iterativo é preferível a abordagens que usam a fórmula matemática mais sã ( n(n+1) / 2), mesmo sendo obviamente muito menos eficiente em termos de velocidade de execução.

Usando a teoria dos números, a implementação do roofcat ainda pode ser ultrapassada em um byte. Cada uma dessas instruções é essencial, mas há uma codificação um pouco mais curta para IMULque seja usada EAX implicitamente como um operando de destino (na verdade, ela usa EDX:EAX, mas podemos simplesmente ignorar os 32 bits superiores do resultado). São apenas 2 bytes para codificar, abaixo dos 3.

LEAleva três bytes também, mas não há realmente nenhuma maneira de contornar isso, porque precisamos incrementar enquanto preservamos o valor original. Se fizéssemos um MOVpara fazer uma cópia, INCestaríamos com 4 bytes. (Em x86-32, onde INChá apenas 1 byte, estaríamos com os mesmos 3 bytes que LEA.)

O deslocamento final à direita é necessário para dividir o resultado pela metade e é certamente mais compacto (e mais eficiente) do que uma multiplicação. No entanto, o código realmente deve estar sendo usado em shrvez de sar, já que está assumindo que o valor de entrada n, é um número inteiro não assinado . (Essa suposição é válida de acordo com as regras, é claro, mas se você souber que a entrada não está assinada, não deverá fazer um deslocamento aritmético assinado, pois o bit superior que está sendo definido em um grande valor não assinado causará o resultado estar incorreto.)

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

Agora apenas 8 bytes (graças a Peter Cordes). Ainda assim, 8> 7.