Estoy sinceramente sorprendido de que esto no se haya hecho ya. Si puede encontrar un hilo existente, márquelo como duplicado o hágamelo saber.

Entrada

Su entrada tiene la forma de cualquier entero positivo mayor o igual a 1.

Salida

Debe generar la suma de todos los enteros entre 1 y el 1 incluido.

Ejemplo

 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.

Tabla de clasificación

Ejecute el fragmento de código a continuación para ver una tabla de clasificación para las respuestas de esta pregunta. (Gracias a programmer5000 y steenbergh por sugerir esto, y Martin Ender por crearlo).

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>

Pyth , 2 bytes

sS

Pruébalo en línea! Entrada implícita Ses un rango indexado en 1 y ses la suma.

Cáscara , 1 byte

Σ

Pruébalo en línea!

¡Incorporado! Σen Husk generalmente se usa para obtener la suma de todos los elementos de una lista, pero cuando se aplica a un número, devuelve exactamente n*(n+1)/2.

Piet , 161 bytes / 16 codeles

Puede interpretarlo con este intérprete de Piet o cargar la imagen en este sitio web y ejecutarlo allí. No estoy seguro sobre el recuento de bytes, si pudiera codificarlo de manera diferente para reducir el tamaño.

Versión ampliada de la imagen de origen:

Explicación

El highlightedtexto muestra la pila actual (creciendo de izquierda a derecha), suponiendo que la entrada del usuario es 5:

Ingrese un número y empújelo en la pila

5

Duplicar este número en la pila

5 5

Empuje 1 (el tamaño del área roja oscura) en la pila

5 5 1

Agrega los dos primeros números

5 6

Multiplica los dos primeros números

30

El área negra asegura que el cursor se mueva hacia la derecha hasta el códec verde claro. Esa transición empuja 2 (el tamaño del verde oscuro) en la pila

30 2

Divide el segundo número en la pila por el primero

15

Pop y salida el número superior (interpretado como número)

[empty]

Al insertar un área blanca, la transición es a nop, el negro atrapa nuestro cursor. Esto finaliza la ejecución del programa.

Archivo original (demasiado pequeño para aquí):

Brain-Flak , 16 bytes

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

Pruébalo en línea!

Esta es una de las pocas cosas en las que Brain Flak es realmente bueno.

Dado que esta es una de las cosas más simples que puede hacer en un ataque cerebral y tiene mucha visibilidad, aquí hay una explicación detallada :

# 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

Pruébalo en línea!

Cómo 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 @Ning a tree)

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

Mathematica, 18 bytes

PolygonalNumber@#&

Mathematica, 19 bytes

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

Mathematica, 20 bytes

(por @Ning a tree)

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

JavaScript (ES6), 10 bytes

n=>n*++n/2

Ejemplo

let f =

n=>n*++n/2

console.log(f(5))

lenguaje 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 probarlo en línea! compila y ejecuta el siguiente programa en 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) );
  }
}

Gracias a @CodyGray y @Peter por -1.

Python 2 , 24 16 bytes

-8 bytes gracias a FryAmTheEggman.

lambda n:n*-~n/2

Pruébalo en línea!

C # (.NET Core) , 10 bytes

n=>n++*n/2

Pruébalo en línea!

Java (OpenJDK 8) , 10 bytes

n->n++*n/2

Pruébalo en línea!

Octava , 22 19 bytes

Porque las operaciones aritméticas son aburridas ...

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

Pruébalo en línea!

Explicación

Dado n, esto crea una matriz n× ncon todas las entradas iguales al número e ; realiza entradas debajo de la diagonal cero; y genera el número de valores distintos de cero.

Jalea , 2 bytes

RS

Pruébalo en línea!

Explicación

RS

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

Suma de Gauss, 3 bytes

‘×H

Explicación

‘×H

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

APL, 3 bytes

+/⍳

Pruébalo en línea!

+/- suma (reducir +), ⍳- rango.

Haskell , 13 bytes

Este es el más corto (creo que pensó):

f n=sum[1..n]

Pruébalo en línea!

Directo, 17 13 bytes

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

¡Gracias @WheatWizard por -4bytes!

Pruébalo en línea!

Pointfree directo, 15 bytes

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

Gracias @nimi por la idea!

Pruébalo en línea!

Punto libre vía sum, 16 bytes

sum.enumFromTo 1

Pruébalo en línea!

Recurrentemente, 22 18 bytes

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

¡Gracias @maple_shaft por la idea y @Laikoni por jugar al golf!

Pruébalo en línea!

Estándar fold, 19 bytes

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

Pruébalo en línea!

Estrellado , 27 22 bytes

¡5 bytes guardados gracias a @miles !

, + +  **       +   *.

Pruébalo en línea!

Explicación

,             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

Pruébalo en línea!

Cómo funciona

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

Suma de Gauss, 4 bytes

>¹*;

Pruébalo en línea!

Cómo funciona

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

Java (OpenJDK 8) , 10 bytes

a->a++*a/2

Pruébalo en línea!

Tomó un momento para jugar golf n->n*(n+1)/2porque soy lento.

Pero esta no es una respuesta real de Java. Definitivamente no es lo suficientemente detallado.

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

No está mal, pero podemos hacerlo mejor.

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

Amo a Java

Cheque , 5 bytes

:)*$p

¡Check ni siquiera es un lenguaje de golf, pero supera a CJam!

Pruébalo en línea!

Explicación:

El número de entrada se coloca en la pila. :lo duplica para dar n, n. Luego se incrementa con ), dando n, n+1. *multiplica los dos juntos y luego $divide el resultado entre 2. pimprime el resultado y el programa finaliza.

MATL , 2 bytes

:s

Pruébalo en línea!

No contento sonriente.

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.

Pruébalo en línea!

Sin golf con comentarios:

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

_{Es 22.6% menos bytes para bucle de lo que es usar x*(x+1)/2}

Julia, 10 bytes

n->n*-~n/2

Pruébalo en línea!

11 bytes (también funciona en Julia 0.4)

n->sum(1:n)

Pruébalo en línea!

Brainfuck, 24 bytes.

La E / S se maneja 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÷

Explicación

:1+×2÷

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

Si implemento el rango en el corto plazo ...

rΣ

Retina , 13 bytes

.+
$*
1
$`1
1

Pruébalo en línea! Explicación: La primera y la última etapa son solo unario ⇔ conversión decimal. La etapa intermedia reemplaza cada uno 1con el número de 1s a su izquierda más otro 1para 1sí mismo, contando así desde 1hasta n, sumando los valores implícitamente.

> <> , 7 + 3 = 10 bytes

Calcula n (n + 1) / 2 .
3 bytes agregados para la bandera -v

:1+2,*n

Pruébalo en línea!

O si la entrada se puede tomar como un código de caracteres:

> <> , 9 bytes

i:1+2,*n;

Pruébalo en línea!

dc , 7 bytes

d1+*2/p

O

d2^+2/p

O

dd*+2/p

Pruébalo en línea!

PHP, 19 bytes

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

usando builtins, 29 bytes:

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

bucle, 31 bytes:

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

Cubix , 12 10 bytes

*,)2I://O@

Versión inicial

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

Pruébalo en línea!

Explicación

Ampliado en un cubo, el código se ve así:

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

El puntero de instrucción (IP) comienza en el I, moviéndose hacia el este. Continúa moviéndose hacia el este hasta que se encuentra con el /espejo, que lo refleja hacia el norte. Cuando la IP llega a la parte superior del código, se ajusta al último .en la tercera línea, moviéndose hacia el sur. Luego se envuelve al penúltimo .en la última línea, moviéndose hacia el norte. Luego alcanza el /espejo nuevamente, que lo refleja hacia el este, solo para que el siguiente lo /refleje hacia el norte nuevamente. Esta vez, la IP se ajusta al penúltimo .en la tercera línea, y luego al último .en la última línea.

Las instrucciones se ejecutan en el siguiente orden.

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 de máquina x86-64, 7 bytes

31 C0
01 C8
E2 FC
C3  

Los bytes anteriores definen una función que acepta un único parámetro ny devuelve un valor que contiene la suma de todos los enteros de 1 a n.

Está escrito en la convención de llamadas x64 de Microsoft , que pasa el parámetro en el ECXregistro. El valor de retorno se deja EAX, como todas las convenciones de llamadas x86 / x86-64.

Mnemónicos de ensamblaje sin golf:

       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

Pruébalo en línea!
_{(La llamada de función C allí está anotada con un atributo que hace que GCC lo llame usando la convención de llamadas de Microsoft que usa mi código de ensamblaje. Si TIO hubiera proporcionado MSVC, esto no sería necesario).}

Según los estándares inusuales del golf de código, verá que este enfoque de bucle iterativo es preferible a los enfoques que usan la fórmula matemática más sensata ( n(n+1) / 2), aunque obviamente es mucho menos eficiente en términos de velocidad de tiempo de ejecución.

Usando la teoría de números, la implementación de ceilingcat todavía puede ser superada por un byte. Cada una de estas instrucciones es esencial, pero hay una codificación ligeramente más corta IMULque se usa EAX implícitamente como un operando de destino (en realidad, se usa EDX:EAX, pero podemos ignorar los 32 bits superiores del resultado). Esto es solo 2 bytes para codificar, en lugar de 3.

LEAtambién toma tres bytes, pero en realidad no hay forma de evitarlo porque necesitamos incrementar mientras conservamos el valor original. Si hiciéramos un MOVpara hacer una copia, INCestaríamos en 4 bytes. (En x86-32, donde INCsolo hay 1 byte, estaríamos en los mismos 3 bytes que LEA.)

El último desplazamiento a la derecha es necesario para dividir el resultado a la mitad, y ciertamente es más compacto (y más eficiente) que una multiplicación. Sin embargo, el código realmente debería estar usando en shrlugar de sar, ya que se supone que el valor de entrada n, es un entero sin signo. (Esa suposición es válida de acuerdo con las reglas, por supuesto, pero si sabe que la entrada no está firmada, entonces no debería estar haciendo un cambio aritmético firmado, ya que el bit superior que se establece en un valor grande sin signo causará el resultado ser incorrecto)

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

Ahora solo 8 bytes (gracias a Peter Cordes). Aún así, 8> 7.