Suma de todos los enteros de 1 a n

63

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

Mostrar fragmento de código

code-golf  math  number 
— GarethPW
fuente
55
— FryAmTheEggman
@FryAmTheEggman Lo siento, tuve un poco de pedo cerebral allí. Veo a que te refieres.
— GarethPW
2
@Aaron te hizo ninja'd por Husk, que acaba de publicarse con una solución de 1 byte
— Skidsdev
77
Sugiero un fragmento de pila.
— programmer5000
1
— Jerry Jeremiah

Respuestas:

32

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.

— León
fuente
1
Por curiosidad, ¿esto ocurre porque el número se arroja a un rango y luego se suma, o está realmente codificado?
— FryAmTheEggman
44
@FryAmTheEggman esto en realidad está codificado, y es similar al comportamiento de otro incorporado, Π, que puede calcular el producto de todos los elementos de una lista o el factorial de un solo número
— Leo
44
Σes un carácter unicode de dos bytes en mi máquina. ¿Supongo que usas la página de códigos 1253? msdn.microsoft.com/en-us/library/cc195055.aspx
— gmatht
55
Página de códigos de
— Jonathan Allan
21

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:

rapapaing-image

Explicación

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

Primera transición Ingrese un número y empújelo en la pila

5

2da transición Duplicar este número en la pila

5 5

3ra transición Empuje 1 (el tamaño del área roja oscura) en la pila

5 5 1

4ta transición Agrega los dos primeros números

5 6

5ta transición Multiplica los dos primeros números

30

6ta transición 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

Séptima transición Divide el segundo número en la pila por el primero

15

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

[empty]

trampa final 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í): Imagen original de origen

— ბიმო
fuente
Pasamos de un texto inteligible (por ejemplo, C) a un texto ininteligible (por ejemplo, Jelly) a imágenes ... ¿Qué sigue? : P
— frarugi87
+1 No he visto una respuesta de Piet con una explicación antes
— MilkyWay90
21

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.
)
— DJMcMayhem
fuente
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 @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]
— J42161217
fuente
44
Parece una lástima saltarse 13, 14 y 17 ...
— No es un árbol
3
Parece un próximo desafío ... o al menos ayúdame a completar la lista.
— J42161217
2
Todavía no tengo nada para 13 o 14 bytes (aparte de solo desestimar sus respuestas más cortas), pero aquí hay otros 26 con un mayor número de bytes .
— No es un árbol
1
@Marcas. el 10.4 funciona bien
— J42161217
1
@Notatree Para su lista, aquí hay un candidato para 35: Array[Boole[#2>=#]& ,{#,#}]~Total~2&
— Mark S.
11

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.

— techo
fuente
1
Probablemente debería usar en shrlugar de sar, para tratar su salida como sin firmar (sin cambios en el tamaño del código). (Detectado por @CodyGray y señalado en su respuesta de 7 bytes add+loop ).
— Peter Cordes
1
Esto parece óptimo para el rendimiento en una implementación de la fórmula de forma cerrada, pero puede guardar un byte utilizando la forma de un operando de mul %edio imul %edi(cada 2B) en lugar de la forma de dos operandos 3B. Golpea a EDX con el resultado de la mitad alta, pero está bien. Multi-operand imulse introdujo más tarde que la forma de un operando, y tiene un código de operación de 2 bytes con un 0Fbyte de escape. Cualquiera de las tres opciones siempre producirá el mismo resultado eax, es solo la mitad alta la que depende de firmado frente a no firmado.
— Peter Cordes
10

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.

— Luis Mendo
fuente
¿Es esto realmente más corto que la versión numérica?
— Esolanging Fruit
@ Challenger5 No, pero la versión numérica es aburrida:@(n)sum(1:n)
— Luis Mendo
2
— Stewie Griffin
8

APL, 3 bytes

+/⍳

Pruébalo en línea!

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

— Uriel
fuente
Esto depende de la indexación. Si la indexación se establece en 0, necesitaría 2 bytes adicionales1+
— Werner
2
La indexación de @Werner es predeterminada, 1por lo que no especifiqué. es común aquí especificar solo cuando se usa ⎕IO←0(y no está incluido en el recuento de bytes)
— Uriel
8

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!

— ბიმო
fuente
7

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
— Luis Mendo
fuente
— millas
@miles ¡Gracias! ¡Muy buena idea!
— Luis Mendo
7

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

— Xanderhall
fuente
1
Si quieres que sea aún más detallado, ¿por qué usar una lambda? : P
— TheLethalCoder
2
Estaba apuntando a lambdas detalladas, podría escribir un programa completo si quisiera ser particularmente elocuente: P
— Xanderhall
1
La misma solución exacta ya fue publicada
— Invierno
2
Debo haberlo pasado por alto, pero en cualquier caso, tiendo a no mirar el contenido de otras respuestas. Prefiero escribir mi propio golf.
— Xanderhall
7

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.

— Fruta Esolanging
fuente
6

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

— Tostadas de ingeniero
fuente
5

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
— Un taco
fuente
2
Es genial que Brainfuck sea capaz de superar algunos idiomas de alto nivel en este desafío.
— GarethPW
¿Es legítimo para mí agregar una respuesta en Lenguage (solo por diversión) usando su código? @ATaco
— V. Courtois
No lo creo, ya que sería el mismo código, simplemente codificado diferente. @ V.Courtois
— ATaco
@ATaco Ahh tienes razón.
— V. Courtois
5

,,, 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Σ
— totalmente humano
fuente
4

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.

— Neil
fuente
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));

bucle, 31 bytes:

while($argn)$s+=$argn--;echo$s;
— Titus
fuente
Supongo que también para:for(;$argn;$s+=$argn--);echo$s;
— Progrock
4

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
— Luke
fuente
4

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.

— Cody Gray
fuente
1
En realidad, un operando imul ecxo mul ecxfuncionaría y guardaría un byte en la implementación de forma cerrada. No lo vi de inmediato; Estaba a punto de comentar que era óptimo tanto para el rendimiento como para el tamaño del código antes de darme cuenta de que un eaxoperando implícito estaba bien.
— Peter Cordes
Me preguntaba si add+ loopsería más corto que imulmientras miraba la otra respuesta. Práctico que hay una convención de llamadas estándar que pasa el primer argumento enecx
— Peter Cordes
1
¡Vaya, no puedo creer que me haya perdido la forma de un operando! Realmente debería saber a estas alturas no decir cosas como "no se puede superar". ¿Cuándo voy a aprender? Gracias @Peter.
— Cody Gray
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.