Somme de tous les entiers de 1 à n


63

Honnêtement, je suis surpris que cela n'ait pas déjà été fait. Si vous pouvez trouver un fil existant, indiquez-le comme un doublon ou faites-le moi savoir.

Contribution

Votre entrée se présente sous la forme d'un entier positif supérieur ou égal à 1.

Sortie

Vous devez sortir la somme de tous les entiers compris entre 1 et le nombre entré.

Exemple

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

OEIS A000217 - Nombres triangulaires: a (n) = binôme (n + 1,2) = n (n + 1) / 2 = 0 + 1 + 2 + ... + n.

Classement

Exécutez l'extrait de code ci-dessous pour afficher un classement pour les réponses à cette question. (Merci à programmer5000 et steenbergh de l'avoir suggéré et à Martin Ender de l'avoir créé.)



@FryAmTheEggman Désolé - je me suis fait avoir un peu de cervelle. Je vois ce que tu veux dire.
GarethPW

2
@ Aaron vous avez ninja par Husk, qui vient d'être posté avec une solution de 1 octet
Skidsdev

7
Je suggère un extrait de pile.
programmer5000

Réponses:



32

Husk , 1 octet

Σ

Essayez-le en ligne!

Builtin! Σdans Husk est généralement utilisé pour obtenir la somme de tous les éléments d'une liste, mais lorsqu'il est appliqué à un nombre, il retourne exactement n*(n+1)/2.


1
Par curiosité, cela se produit-il parce que le nombre est converti dans une plage, puis additionné, ou est-ce réellement codé en dur?
FryAmTheEggman

4
@FryAmTheEggman c'est en fait un code dur, et il est similaire au comportement d'un autre élément intégré,, qui peut calculer le produit de tous les éléments d'une liste ou de la factorielle d'un nombre unique
Leo

4
Σest un caractère unicode à deux octets sur ma machine. Je suppose que vous utilisez la page de code 1253? msdn.microsoft.com/en-us/library/cc195055.aspx
mardi 16


21

Piet , 161 octets / 16 codels

Vous pouvez l'interpréter avec cet interprète Piet ou télécharger l'image sur ce site et l'exécuter là-bas. Pas sûr du nombre d'octets, si je pouvais le coder différemment pour réduire la taille.

Version agrandie de l'image source:

rapapaing-image

Explication

Le highlightedtexte montre la pile actuelle (croissant de gauche à droite), en supposant que l'utilisateur entre 5:

1ère transition Entrer un nombre et le pousser sur la pile

5

2ème transition Dupliquer ce numéro sur la pile

5 5

3ème transition Poussez 1 (la taille de la zone rouge foncé) sur la pile

5 5 1

4ème transition Ajouter les deux premiers chiffres

5 6

5ème transition Multiplie les deux premiers chiffres

30

6ème transition La zone noire permet de s'assurer que le curseur se déplace vers la droite jusqu'au code vert clair. Cette transition pousse 2 (la taille du vert foncé) sur la pile

30 2

7ème transition Divise le deuxième nombre de la pile par le premier

15

8ème transition Pop et sortie le nombre supérieur (interprété comme nombre)

[empty]

piège final En insérant une zone blanche, la transition est un nop, le noir piège notre curseur. Ceci termine l'exécution du programme.

Fichier original (beaucoup trop petit pour ici): Image source originale


Nous sommes passés d’un texte intelligible (par exemple C) à un texte inintelligible (par exemple Jelly) en images ... Et ensuite? : P
frarugi87

+1 Je n'ai pas encore vu de réponse de Piet avec une explication auparavant
MilkyWay90

21

Brain-Flak , 16 octets

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

Essayez-le en ligne!

C’est l’une des rares choses pour lesquelles la flak cérébrale est vraiment bonne.

Puisque c'est l'une des choses les plus simples que vous puissiez faire dans brain-flak et qu'il a beaucoup de visibilité, voici une explication détaillée :

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


18

Mathematica, 9 octets

#(#+1)/2&

Mathematica, 10 octets

(#^2+#)/2&

Mathematica, 11 octets

Tr@Range@#&

Mathematica, 12 octets

i~Sum~{i,#}&

Mathematica, 14 octets

(par @ user71546)

1/2/Beta[#,2]&

Mathematica, 15 octets

Tr[#&~Array~#]&

Mathematica, 16 octets

Binomial[#+1,2]&

Mathematica, 17 octets

(par @Non un arbre)

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

Mathematica, 18 octets

PolygonalNumber@#&

Mathematica, 19 octets

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

Mathematica, 20 octets

(par @Non un arbre)

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

4
Il semble dommage de sauter 13, 14 et 17…
Pas un arbre

3
Cela ressemble à un prochain défi ... ou du moins m'aide à compléter la liste.
J42161217

2
Je n'ai toujours rien pour 13 ou 14 octets (mis à part le fait de ne pas mettre vos réponses plus courtes au golf), mais voici 26 autres avec un plus grand nombre d'octets .
Pas un arbre

1
@Des notes. sur 10.4 fonctionne très bien
J42161217

1
@Notatree Pour votre liste, voici un candidat pour 35: Array[Boole[#2>=#]& ,{#,#}]~Total~2&
Mark S.


11

Langage machine x86_64 (Linux), 9 à 8 octets

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

Pour l' essayer en ligne! compiler et exécuter le programme C suivant.

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

Merci à @CodyGray et @Peter pour -1.


1
Vous devriez probablement utiliser à la shrplace de sar, pour traiter votre sortie comme non signée (aucun changement dans la taille du code). (Repéré par @CodyGray et souligné dans sa réponse de 7 octets add+loop ).
Peter Cordes

1
Cela semble optimal pour les performances dans une implémentation de la formule de forme fermée, mais vous pouvez enregistrer un octet en utilisant la forme à un opérande de mul %ediou imul %edi(chaque 2B) au lieu du formulaire 3B à deux opérandes. Cela frappe EDX avec le résultat dans la moitié haute, mais ça va. Multi-opérande a imulété introduit plus tard que le formulaire à un opérande et possède un opcode de 2 octets avec un 0Foctet d'échappement. Chacune des trois options produira toujours le même résultat eax, seule la moitié supérieure dépend de la signature contre la non-signature.
Peter Cordes




10

Octave , 22 19 octets

Parce que les opérations arithmétiques sont ennuyeuses ...

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

Essayez-le en ligne!

Explication

Étant donné n, cela crée une matrice n× navec toutes les entrées égales au nombre e ; fait des entrées en dessous de la diagonale zéro; et affiche le nombre de valeurs non nulles.


Est-ce réellement plus court que la version numérique?
Esolanging Fruit

@ Challenger5 Non, mais la version numérique est ennuyeuse:@(n)sum(1:n)
Luis Mendo



8

APL, 3 octets

+/⍳

Essayez-le en ligne!

+/- somme (réduction +), - plage.


Cela dépend de l'indexation. Si l'indexation est définie sur 0, vous aurez besoin de 2 octets supplémentaires1+
Werner

2
L'indexation @Werner est la valeur par défaut, 1donc je n'ai pas précisé. sa commune ici pour spécifier que lors de l'utilisation ⎕IO←0(et il ne fait pas partie du nombre d'octets)
Uriel

8

Haskell , 13 octets

C'est le plus court (je pense pensé):

f n=sum[1..n]

Essayez-le en ligne!

Direct, 17 à 13 octets

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

Merci @ WheatWizard pour les -4octets!

Essayez-le en ligne!

Pointfree direct, 15 octets

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

Merci @nimi pour l'idée!

Essayez-le en ligne!

Pointfree via sum, 16 octets

sum.enumFromTo 1

Essayez-le en ligne!

Récursivement, 22 18 octets

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

Merci @maple_shaft pour l'idée et @Laikoni pour l'avoir jouée au golf!

Essayez-le en ligne!

Standard fold, 19 octets

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

Essayez-le en ligne!


7

Étoilé , 27 22 octets

5 octets sauvés grâce à @miles !

, + +  **       +   *.

Essayez-le en ligne!

Explication

,             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


@miles Merci! Très bonne idée!
Luis Mendo


7

Java (OpenJDK 8) , 10 octets

a->a++*a/2

Essayez-le en ligne!

n->n*(n+1)/2J'ai pris un moment pour jouer au golf parce que je suis lent.

Mais ce n'est pas une vraie réponse Java. Ce n'est certainement pas assez verbeux.

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

Pas mal, mais on peut faire mieux.

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

J'aime Java.


1
Si vous voulez qu'il soit encore plus bavard, pourquoi utiliser un lambda!? : P
TheLethalCoder

2
Je visais des lambdas verbeux, je pourrais écrire un programme complet si je voulais être particulièrement éloquent: P
Xanderhall le

1
La solution exacte était déjà affichée
hiver

2
J'ai dû le manquer, mais dans tous les cas, j'ai tendance à ne pas regarder le contenu d'autres réponses. Je préfère écrire mon propre golf.
Xanderhall

7

Chèque , 5 octets

:)*$p

Check n'est même pas une langue de golf, mais il bat CJam!

Essayez-le en ligne!

Explication:

Le numéro saisi est placé sur la pile. :le duplique à donner n, n. Il est ensuite incrémenté avec ), donnant n, n+1. *multiplie les deux ensemble, puis $divise le résultat par 2. pimprime le résultat et le programme se termine.



6

Taxi , 687 octets

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.

Essayez-le en ligne!

Non-golfé avec des commentaires:

[ 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 faut 22,6% moins d'octets à boucler qu'à utiliser x*(x+1)/2



5

Brainfuck, 24 octets.

Les E / S sont traitées comme des octets.

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

A expliqué

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

2
C’est plutôt cool que Brainfuck réussisse à battre des langues de niveau supérieur dans ce défi.
GarethPW

Est-ce légitime pour moi d'ajouter une réponse dans Lenguage (juste pour le plaisir) en utilisant votre code? @ATaco
V. Courtois

Je ne pense pas, car ce serait le même code, mais encodé différemment. @ V. Courtois
ATaco le

@ ATaco Ahh tu as raison.
V. Courtois

5

,,, 6 octets

:1+×2÷

Explication

:1+×2÷

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

Si j'implémente la gamme dans un proche avenir ...


4

Retina , 13 octets

.+
$*
1
$`1
1

Essayez-le en ligne! Explication: Les première et dernière étapes ne sont que des conversions ary décimales unaires. L'étage intermédiaire remplace chacun 1par le nombre de 1s à sa gauche plus un autre 1pour le 1lui - même, en comptant ainsi de 1à n, en sommant les valeurs implicitement.




4

PHP, 19 octets

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

using builtins, 29 bytes:

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

boucle, 31 octets:

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

Je suppose qu'un pour aussi:for(;$argn;$s+=$argn--);echo$s;
Progrock

4

Cubix , 12 à 10 octets

*,)2I://O@

Version initiale

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

Essayez-le en ligne!

Explication

Développé sur un cube, le code ressemble à ceci:

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

Le pointeur d'instruction (IP) commence à l'est I, en direction de l'est. Il continue de se déplacer vers l’est jusqu’à atteindre le /miroir, qui le reflète au nord. Lorsque l'IP atteint le haut du code, il passe à la dernière ligne .de la troisième ligne, en direction du sud. Ensuite, vous passez à l’avant .-dernière ligne de la dernière ligne en direction du nord. Ensuite, il atteint à /nouveau le miroir, qui le reflète vers l'est, mais le prochain /réfléchit à nouveau vers le nord. Cette fois, l’IP passe à l’avant-dernière ligne .de la troisième ligne, puis à la dernière .de la dernière ligne.

Les instructions sont exécutées dans l'ordre suivant.

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

4

Code machine x86-64, 7 octets

31 C0
01 C8
E2 FC
C3  

Les octets ci-dessus définissent une fonction qui accepte un seul paramètre net renvoie une valeur contenant la somme de tous les entiers allant de 1 à n.

Il est écrit dans la convention d'appel Microsoft x64 , qui transmet le paramètre dans le ECXregistre. La valeur de retour est laissée à l' EAXintérieur, comme toutes les conventions d'appel x86 / x86-64.

Mnémoniques d'assemblées non golfées:

       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

Essayez-le en ligne!
(L'appel de fonction C à cet emplacement est annoté avec un attribut qui force GCC à l'appeler en utilisant la convention d'appel de Microsoft utilisée par mon code d'assembly. Si TIO avait fourni MSVC, cela ne serait pas nécessaire.)


Selon les normes inhabituelles du code golf, vous voyez que cette approche de boucle itérative est préférable aux approches qui utilisent la formule mathématique plus saine ( n(n+1) / 2), même si elle est évidemment beaucoup moins efficace en termes de vitesse d’exécution.

En utilisant la théorie des nombres, la mise en œuvre de ceilingcat peut toujours être battue d'un octet. Chacune de ces instructions est essentielle, mais il existe un codage légèrement plus court IMULqui utilise EAX implicitement comme opérande de destination (en fait, il utilise EDX:EAX, mais nous pouvons simplement ignorer les 32 bits supérieurs du résultat). C’est seulement 2 octets à encoder, au lieu de 3.

LEAprend également trois octets, mais il n’ya vraiment aucune solution, car nous devons incrémenter tout en préservant la valeur initiale. Si nous faisions une MOVcopie INC, nous serions à 4 octets. (En x86-32, où INCest seulement 1 octet, nous serions aux mêmes 3 octets que LEA.)

Le dernier décalage à droite est nécessaire pour diviser le résultat en deux et est certainement plus compact (et plus efficace) qu'une multiplication. Cependant, le code devrait réellement être utilisé à la shrplace de sar, puisqu'il suppose que la valeur d'entrée n, est un entier non signé . (Cette hypothèse est bien sûr conforme aux règles, mais si vous savez que l'entrée est non signée, vous ne devriez pas effectuer de décalage arithmétique signé, car le bit supérieur défini dans une grande valeur non signée entraînera le résultat. être incorrect.)

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

Maintenant, seulement 8 octets (merci à Peter Cordes). Pourtant, 8> 7.


1
En fait, un opérande imul ecxou mul ecxfonctionnerait et économiserait un octet dans la mise en oeuvre en forme fermée. Je n'ai pas remarqué ça tout de suite. J'étais sur le point de dire que la performance et la taille du code étaient optimales avant de réaliser qu'un eaxopérande implicite convenait.
Peter Cordes

Je me demandais si add+ loopserait plus court qu'en imulregardant l'autre réponse. Bien qu'il y ait une convention d'appel standard qui passe le premier argumentecx
Peter Cordes le

1
Wow, je ne peux pas croire que j'ai raté la forme à un opérande! Je devrais vraiment savoir maintenant de ne pas dire des choses comme "est imbattable". Quand vais-je apprendre? Merci, Peter.
Cody Grey
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.