Sono sinceramente sorpreso che questo non sia già stato fatto. Se riesci a trovare un thread esistente, contrassegnalo come duplicato o fammi sapere.

Ingresso

Il tuo input è sotto forma di qualsiasi numero intero positivo maggiore o uguale a 1.

Produzione

È necessario generare la somma di tutti i numeri interi compresi tra 1 incluso e il numero immesso.

Esempio

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

OEIS A000217 - Numeri triangolari: a (n) = binomiale (n + 1,2) = n (n + 1) / 2 = 0 + 1 + 2 + ... + n.

Classifica

Esegui lo snippet di codice seguente per visualizzare una classifica per le risposte a questa domanda. (Grazie a programmer5000 e steenbergh per avermi suggerito questo, e Martin Ender per averlo creato.)

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 byte

sS

Provalo online! Input implicito. Sè un intervallo indicizzato 1 ed sè la somma.

Buccia , 1 byte

Σ

Provalo online!

Builtin! Σin Husk viene solitamente utilizzato per ottenere la somma di tutti gli elementi di un elenco, ma quando applicato a un numero restituisce esattamente n*(n+1)/2.

Piet , 161 byte / 16 codici

Puoi interpretarlo con questo interprete Piet o caricare l'immagine su questo sito Web ed eseguirlo lì. Non sono sicuro del numero di byte, se potessi codificarlo in modo diverso per ridurre le dimensioni.

Versione ingrandita dell'immagine di origine:

Spiegazione

Il highlightedtesto mostra lo stack corrente (crescente da sinistra a destra), supponendo che l'input dell'utente sia 5:

Inserisci un numero e spingilo nello stack

5

Duplica questo numero nello stack

5 5

Spingere 1 (la dimensione dell'area rosso scuro) sulla pila

5 5 1

Aggiungi i primi due numeri

5 6

Moltiplica i primi due numeri

30

L'area nera assicura che il cursore si sposta verso il basso fino al codice verde chiaro. Quella transizione spinge 2 (la dimensione del verde scuro) in pila

30 2

Dividi il secondo numero in pila per il primo

15

Pop e output il numero superiore (interpretato come numero)

[empty]

Inserendo un'area bianca, la transizione è a nop, il nero intrappola il nostro cursore. Questo termina l'esecuzione del programma.

File originale (troppo piccolo per qui):

Brain-Flak , 16 byte

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

Provalo online!

Questa è una delle poche cose in cui il brain-flak è davvero bravo.

Dal momento che questa è una delle cose più semplici che puoi fare nel brain-flak e ha molta visibilità, ecco una spiegazione dettagliata :

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

Oasi , 3 byte

n+0

Provalo online!

Come funziona

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

Mathematica, 9 byte

#(#+1)/2&

Mathematica, 10 byte

(#^2+#)/2&

Mathematica, 11 byte

Tr@Range@#&

Mathematica, 12 byte

i~Sum~{i,#}&

Mathematica, 14 byte

(di @ user71546)

1/2/Beta[#,2]&

Mathematica, 15 byte

Tr[#&~Array~#]&

Mathematica, 16 byte

Binomial[#+1,2]&

Mathematica, 17 byte

(di @Non un albero)

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

Mathematica, 18 byte

PolygonalNumber@#&

Mathematica, 19 byte

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

Mathematica, 20 byte

(di @Non un albero)

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

JavaScript (ES6), 10 byte

n=>n*++n/2

Esempio

let f =

n=>n*++n/2

console.log(f(5))

linguaggio macchina x86_64 (Linux), 9 8 byte

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

Per provarlo online! compilare ed eseguire il seguente programma 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) );
  }
}

Grazie a @CodyGray e @Peter per -1.

Python 2 , 24 16 byte

-8 byte grazie a FryAmTheEggman.

lambda n:n*-~n/2

Provalo online!

C # (.NET Core) , 10 byte

n=>n++*n/2

Provalo online!

Java (OpenJDK 8) , 10 byte

n->n++*n/2

Provalo online!

Ottava , 22 19 byte

Perché le operazioni aritmetiche sono noiose ...

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

Provalo online!

Spiegazione

Dato n, questo crea una matrice n× ncon tutte le voci uguali al numero e ; inserisce voci sotto lo zero diagonale; e genera il numero di valori diversi da zero.

Gelatina , 2 byte

RS

Provalo online!

Spiegazione

RS

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

Somma di Gauss, 3 byte

‘×H

Spiegazione

‘×H

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

APL, 3 byte

+/⍳

Provalo online!

+/- somma (riduzione +), ⍳- intervallo.

Haskell , 13 byte

Questo è il più breve ( penso che abbia pensato):

f n=sum[1..n]

Provalo online!

Diretto, 17 13 byte

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

Grazie @WheatWizard per i -4byte!

Provalo online!

Diretto senza punti, 15 byte

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

Grazie @nimi per l'idea!

Provalo online!

Pointfree via sum, 16 byte

sum.enumFromTo 1

Provalo online!

Ricorsivamente, 22 18 byte

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

Grazie @maple_shaft per l'idea e @Laikoni per averlo giocato a golf!

Provalo online!

Standard fold, 19 byte

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

Provalo online!

Stellato , 27 22 byte

5 byte salvati grazie a @miles !

, + +  **       +   *.

Provalo online!

Spiegazione

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

LO

Provalo online!

Come funziona

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

Somma di Gauss, 4 byte

>¹*;

Provalo online!

Come funziona

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

Java (OpenJDK 8) , 10 byte

a->a++*a/2

Provalo online!

n->n*(n+1)/2Mi sono preso un momento per giocare a golf perché sono lento.

Ma questa non è una vera risposta Java. Non è assolutamente abbastanza dettagliato.

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

Non male, ma possiamo fare di meglio.

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

Adoro Java.

Controllare , 5 byte

:)*$p

Controllare non è nemmeno un linguaggio da golf, ma batte CJam!

Provalo online!

Spiegazione:

Il numero di input viene inserito nello stack. :lo duplica per dare n, n. Viene quindi incrementato con ), dando n, n+1. *moltiplica i due insieme, quindi $divide il risultato per 2. pstampa il risultato e il programma termina.

MATL , 2 byte

:s

Provalo online!

Faccina non felice.

Taxi , 687 byte

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.

Provalo online!

Non golfato con commenti:

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

_{Il loop è del 22,6% in meno di byte rispetto a quello da utilizzare x*(x+1)/2}

Julia, 10 byte

n->n*-~n/2

Provalo online!

11 byte (funziona anche su Julia 0.4)

n->sum(1:n)

Provalo online!

Brainfuck, 24 byte.

L'I / O è gestito come byte.

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

spiegato

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

:1+×2÷

Spiegazione

:1+×2÷

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

Se implementerò il range in qualsiasi momento presto ...

rΣ

Retina , 13 byte

.+
$*
1
$`1
1

Provalo online! Spiegazione: Il primo e l'ultimo stadio sono solo unari ⇔ conversione decimale. Lo stadio intermedio sostituisce ciascuno 1con il numero di 1s alla sua sinistra più un altro 1per 1se stesso, contando così da 1a n, sommando implicitamente i valori.

> <> , 7 + 3 = 10 byte

Calcola n (n + 1) / 2 .
3 byte aggiunti per il flag -v

:1+2,*n

Provalo online!

O se l'input può essere preso come un codice carattere:

> <> , 9 byte

i:1+2,*n;

Provalo online!

dc , 7 byte

d1+*2/p

O

d2^+2/p

O

dd*+2/p

Provalo online!

PHP, 19 byte

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

usando builtins, 29 byte:

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

loop, 31 byte:

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

Cubix , 12 10 byte

*,)2I://O@

Versione iniziale

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

Provalo online!

Spiegazione

Espanso su un cubo, il codice è simile al seguente:

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

Il puntatore dell'istruzione (IP) inizia in Idirezione est. Continua a spostarsi verso est fino a quando non incontra lo /specchio, che lo riflette a nord. Quando l'IP raggiunge la cima del codice, si avvolge fino all'ultimo .sulla terza riga, spostandosi verso sud. Quindi si avvolge al penultimo penultimo ., spostandosi verso nord. Quindi raggiunge di /nuovo lo specchio, che lo riflette a est, solo per il prossimo /a rifletterlo di nuovo a nord. Questa volta, l'IP passa al penultimo .sulla terza riga, e quindi all'ultima .sull'ultima riga.

Le istruzioni vengono eseguite nel seguente ordine.

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

x86-64 Codice macchina, 7 byte

31 C0
01 C8
E2 FC
C3  

I byte precedenti definiscono una funzione che accetta un singolo parametro, n e restituisce un valore contenente la somma di tutti i numeri interi da 1 a n.

È scritto nella convenzione di chiamata x64 di Microsoft , che passa il parametro inECX registro. Il valore restituito viene lasciato EAX, come tutte le convenzioni di chiamata x86 / x86-64.

Mnemonici di assemblaggio non golfati:

       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

Provalo online!
_{(La chiamata della funzione C è annotata con un attributo che fa sì che GCC la chiami utilizzando la convenzione di chiamata Microsoft utilizzata dal mio codice assembly. Se TIO avesse fornito MSVC, ciò non sarebbe necessario.)}

Secondo gli insoliti standard del code golf, si vede che è preferibile questo approccio di loop iterativo approcci che usano la formula matematica più sana ( n(n+1) / 2), anche se ovviamente è notevolmente meno efficiente in termini di velocità di runtime.

Usando la teoria dei numeri, l'implementazione di ceilingcat può ancora essere battuta di un byte. Ognuna di queste istruzioni è essenziale, ma esiste una codifica leggermente più breve IMULche utilizza EAX implicitamente come operando di destinazione (in realtà, utilizzaEDX:EAX , ma possiamo semplicemente ignorare i 32 bit superiori del risultato). Questo è solo 2 byte da codificare, invece di 3.

LEAprende tre byte pure, ma non c'è davvero nessun modo per aggirare questo, perché abbiamo bisogno di incremento , mentre preservando il valore originale. Se avessimo fatto una MOVcopia per fare una copia, INCsaremmo stati a 4 byte. (In x86-32, doveINC è solo 1 byte, saremmo agli stessi 3 byte di LEA.)

Lo spostamento a destra finale è necessario per dividere il risultato a metà ed è certamente più compatto (e più efficiente) di una moltiplicazione. Tuttavia, il codice dovrebbe davvero essere utilizzato shrinvece di sar, poiché presuppone che il valore di input n, sia un numero intero senza segno . (Tale presupposto è valido secondo le regole, ovviamente, ma se sai che l'input è senza segno, non dovresti fare uno spostamento aritmetico con segno, poiché il bit superiore impostato in un grande valore senza segno causerà il risultato per essere errato.)

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

Ora solo 8 byte (grazie a Peter Cordes). Ancora, 8> 7.