Soma de todos os números inteiros de 1 a n

63

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

Mostrar snippet de código

code-golf  math  number 
— GarethPW
fonte
5
— FryAmTheEggman
@FryAmTheEggman Desculpe - teve um pouco de peido no cérebro por lá. Eu vejo o que você quer dizer.
— GarethPW
2
@ Aaron você se ninja'd por Husk, que foi apenas publicado com uma solução de 1 byte
— Skidsdev
7
Sugiro um trecho de pilha.
— programmer5000
11
— Jerry Jeremiah

Respostas:

32

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.

— Leo
fonte
11
Por curiosidade, isso ocorre porque o número é convertido em um intervalo e depois somado, ou é realmente codificado?
— FryAmTheEggman
4
@FryAmTheEggman isso é realmente codificado e é semelhante ao comportamento de outro built-in, Π, que pode calcular o produto de todos os elementos de uma lista ou o fatorial de um único número.
— Leo
4
Σé um caractere unicode de dois bytes na minha máquina. Eu acho que você usa a página de código 1253? msdn.microsoft.com/pt-br/library/cc195055.aspx
— gmatht
5
Página de código
— Jonathan Allan
21

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:

rapapaing-image

Explicação

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

1ª transição Insira um número e empurre-o para a pilha

5

2ª transição Duplique esse número na pilha

5 5

3ª transição Empurre 1 (o tamanho da área vermelha escura) na pilha

5 5 1

4ª transição Adicione os dois primeiros números

5 6

5ª transição Multiplique os dois principais números

30

6ª transição 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

7ª transição Divida o segundo número na pilha pelo primeiro

15

8ª transição Abre e gera o número superior (interpretado como número)

[empty]

armadilha final 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): Imagem de origem original

— ბიმო
fonte
Passamos de um texto inteligível (por exemplo, C) para texto ininteligível (por exemplo, Jelly) para imagens ... O que vem a seguir? : P
— frarugi87
+1 Eu realmente não vi uma resposta Piet com uma explicação antes
— MilkyWay90
21

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.
)
— DJMcMayhem
fonte
18

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]
— J42161217
fonte
4
Parece uma vergonha para pular 13, 14 e 17 ...
— Não uma árvore
3
Parece um próximo desafio .... ou pelo menos me ajude a completar a lista.
— J42161217
2
Eu ainda não tenho nada para 13 ou 14 bytes (além de cancelar suas respostas mais curtas), mas aqui estão outros 26 com contagens de bytes maiores .
— Não é uma árvore
11
@MarkS. em 10.4 funciona bem
— J42161217 25/07
11
@Notatree Para sua lista, aqui está um candidato para 35: Array[Boole[#2>=#]& ,{#,#}]~Total~2&
— Mark S.
11

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.

— teto
fonte
11
Você provavelmente deve usar em shrvez de sartratar sua saída como não assinada (sem alteração no tamanho do código). (Detectado por @CodyGray e apontado em sua resposta de 7 bytes add+loop ).
— 22617 Peter Cordes
11
Isso parece ótimo para o desempenho em uma implementação da fórmula de formulário fechado, mas você pode salvar um byte usando o formulário de um operando de mul %ediou imul %edi(cada 2B) em vez do formulário de dois operandos 3B. Ele derruba o EDX com o resultado da metade alta, mas tudo bem. O multi-operando imulfoi introduzido mais tarde que o formulário de um operando e possui um código de operação de 2 bytes com um 0Fbyte de escape. Qualquer uma das três opções sempre produzirá o mesmo resultado eax, é apenas a metade alta que depende de assinado versus não assinado.
— 22617 Peter Cordes
10

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.

— Luis Mendo
fonte
Isso é realmente mais curto que a versão numérica?
— Esolanging Fruit
@ Challenger5 Não, mas a versão numérica é chata:@(n)sum(1:n)
— Luis Mendo
2
— Stewie Griffin
8

APL, 3 bytes

+/⍳

Experimente online!

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

— Uriel
fonte
Isso depende da indexação. Se a indexação é definido como 0, então você precisa de um 2 bytes adicionais1+
— Werner
2
A indexação @Werner é o padrão, 1então não especifiquei. sua posição comum aqui para especificar somente quando usar ⎕IO←0(e não incluídos na contagem de bytes)
— Uriel
8

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!

— ბიმო
fonte
7

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
— Luis Mendo
fonte
— miles
@miles Obrigado! Muito boa ideia!
— Luis Mendo
7

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.

— Xanderhall
fonte
11
Se você quer que seja ainda mais detalhado, por que usar uma lambda !? : P
— TheLethalCoder
2
Eu estava apontando para lambdas detalhado, eu poderia escrever um programa completo se eu queria ser particularmente eloquente: P
— Xanderhall
11
A mesma solução exata já foi postada
— Inverno
2
Devo ter esquecido, mas, de qualquer forma, costumo não olhar o conteúdo de outras respostas. Eu prefiro escrever meu próprio golfe.
— Xanderhall
7

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.

— Esolanging Fruit
fonte
6

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

— Engenheiro Toast
fonte
5

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
— ATaco
fonte
2
É muito legal que o Brainfuck consiga superar alguns idiomas de alto nível nesse desafio.
— 21717 GarethPW
É legítimo para mim adicionar uma resposta no Lenguage (apenas por diversão) usando seu código? @ATaco
— V. Courtois
Eu acho que não, pois seria o mesmo código, apenas codificado diferente. @ V.Courtois
— ATaco
@ATaco Ahh, você está certo.
— V. Courtois
5

,,,, 6 bytes

:1+×2÷

Explicação

:1+×2÷

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

Se eu implementar intervalo em breve ...

rΣ
— totalmente humano
fonte
4

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.

— Neil
fonte
4

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;
— Titus
fonte
Acho que também para:for(;$argn;$s+=$argn--);echo$s;
— Progrock 13/10
4

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
— Lucas
fonte
4

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.

— Cody Gray
fonte
11
Na verdade, um operando imul ecxou mul ecxfuncionaria e salvaria um byte na implementação em formato fechado. Não percebi isso imediatamente; Eu estava prestes a comentar que era ótimo tanto para o desempenho quanto para o tamanho do código antes de perceber que um eaxoperando implícito estava correto.
— 22617 Peter Cordes
Gostaria de saber se add+ loopseria mais curto do que imulenquanto olhava para a outra resposta. Handy que há uma convenção de chamada padrão que passa o primeiro argumento emecx
— Peter Cordes
11
Uau, não acredito que perdi o formulário de um operando! Eu realmente deveria saber agora não dizer coisas como "não pode ser derrotado". Quando vou aprender ?! Obrigado, Peter.
— Cody Gray
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.