Voici les 100 premiers numéros d'une séquence simple:

0,1,0,2,1,4,3,7,6,11,10,16,15,22,21,29,28,37,36,46,45,56,55,67,66,79,78,92,91,106,105,121,120,137,136,154,153,172,171,191,190,211,210,232,231,254,253,277,276,301,300,326,325,352,351,379,378,407,406,436,435,466,465,497,496,529,528,562,561,596,595,631,630,667,666,704,703,742,741,781,780,821,820,862,861,904,903,947,946,991,990,1036,1035,1082,1081,1129,1128,1177,1176,1226

Comment fonctionne cette séquence?

n: 0 1     2           3     4     5     6     7     8      9       10      11      12

   0,      1-1=0,      2-1=1,      4-1=3,      7-1=6,       11-1=10,        16-1=15,      
     0+1=1,      0+2=2,      1+3=4,      3+4=7,      6+5=11,        10+6=16,        15+7=22

• a(0) = 0
• Pour chaque impair n(index 0), c'est a(n-1) + X(où X=1et augmente de 1 à chaque fois qu'il est accédé)
• Pour chaque pair n(indexé 0), c'esta(n-1) - 1

Défi:

Un des:

• Étant donné un entier en entrée n, sortez le n'ème nombre dans la séquence.
• Étant donné un entier d'entrée n, sortez les premiers nnombres de la séquence.
• Sortez la séquence indéfiniment sans prendre d'entrée ( ou prendre une entrée vide non utilisée ).

Règles du défi:

• L'entrée npeut être indexée à 0 ou à 1.
• Si vous sortez (une partie de) la séquence, vous pouvez utiliser une liste / tableau, imprimer sur STDOUT avec n'importe quel délimiteur (espace, virgule, nouvelle ligne, etc.). Ton appel.
• Veuillez indiquer laquelle des trois options vous avez utilisée dans votre réponse.
• Vous devrez prendre en charge au moins les 10 000 premiers numéros (le 10 000 e numéro est 12,497,501).

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues autres que le golf de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si possible.

Cas de test:

Collez avec les 10 001 premiers chiffres de la séquence. N'hésitez pas à choisir celui que vous souhaitez.

Quelques chiffres plus élevés:

n (0-indexed)    Output:

68,690           589,772,340
100,000          1,249,975,000
162,207          3,288,888,857
453,271          25,681,824,931
888,888          98,765,012,346
1,000,000        124,999,750,000

Python 2 , 32 28 25 octets

lambda n:(~-n|1)**2/8+n%2

Essayez-le en ligne!

Renvoie le n-ième nombre ( 0-indexé)

Excel, 31 octets

La réponse est 0indexée. Sort nle nombre.

=(A1^2+IF(ISODD(A1),7,-2*A1))/8

La séquence décrite n'est finalement que deux séquences entrelacées:

ODD:   (x^2+x+2)/2
EVEN:  (x^2-x)/2

L'entrelacement de ceux-ci dans une 0séquence indexée donne:

a = (x^2 - 2x)/8 if even
a = (x^2 + 7 )/8 if odd

Qui donne:

=IF(ISODD(A1),(A1^2+7)/8,(A1^2-2*A1)/8)

que nous jouons au golf jusqu'aux 31octets.

En utilisant la même approche, 1indexé donne des 37octets:

=(A1^2-IF(ISODD(A1),4*A1-3,2*A1-8))/8

Gelée , 6 octets

Rj-ḣ⁸S

Essayez-le en ligne!

0 indexé. Résultatsn le numéro e.

Explication:

Rj-ḣ⁸S Arguments: z
R      [1..x]: z (implicit)
 j-    Join x with y: ^, -1
   ḣ⁸  Take first y of x: ^, z
     S Sum: ^

JavaScript (Node.js) , 23 octets

x=>(7+(x-2|1)**2)/8-x%2

1 indexé. Essayez-le en ligne!

f(x) = f(x+1) + 1 if x is even
     = SUM{1..(x-3)/2} if x is odd

SUM{1..(x-3)/2}
= (1+(x-3)/2)*((x-3)/2)/2
= (x-1)*(x-3)/8
= ((x-2)^2-1)/8

Haskell , 40 38 37 octets

scanl(flip($))0$[1..]>>=(:[pred]).(+)

Renvoie une liste infinie, essayez-la en ligne!

Explication

scanlprend trois arguments f, initet xs( [ x ₀ , x ₁ ... ] ) et construit une nouvelle liste:

[ a ₀ = init , a ₁ = f (a ₀ , x ₀ ) , a ₂ = f (a ₁ , x ₁ ) ... ]

Nous définissons init = 0et utilisons l' ($)opérateur d'application inversé (il applique donc un _i à la fonction x _i ), maintenant nous n'avons besoin que d'une liste de fonctions - la liste [1..]>>=(:[pred]).(+)est une liste infinie avec les bonnes fonctions:

[(+1),(-1),(+2),(-1),(+3),(-1),(+4),...

Alternative intéressante, 37 octets

flipayant le type que (a -> b -> c) -> b -> a -> cnous pourrions également utiliser id :: d -> dau lieu de à ($)cause de l'inférence de type de Haskell le type dserait unifié aveca -> b , nous donnant la même chose.

Essayez-le en ligne!

modifier

^{-2 octets en utilisant (>>=)au lieu de do-notation.}

^{-1 octet en utilisant scanlau lieu de zipWith.}

Haskell , 25 octets

scanl(+)0$(:[-1])=<<[1..]

Essayez-le en ligne!

Construit une liste infinie.

Haskell , 27 octets

0:0%1
a%d=a+1:a:(a+d)%(d+1)

Essayez-le en ligne!

Haskell , 30 octets

0:do a<-scanl(+)0[1..];[a+1,a]

Essayez-le en ligne!

05AB1E , 10 octets

ÎF<NÈi¼¾>+

Essayez-le en ligne!

Explication

Î             # initialize stack with: 0, input
 F            # for N in [0 ... input-1] do:
  <           # decrement the current number
   NÈi        # if N is even
      ¼       # increment a counter
       ¾>     # push counter+1
         +    # add to current number

Encore 10 octets: ÎFNÈN;Ì*<O

Octave , 32 octets

@(x)fix((x-~(m=mod(x,2)))^2/8)+m

Essayez-le en ligne!

Sort le nième nombre, indexé 0. Utilise la même formule que plusieurs autres réponses.

APL (Dyalog Unicode) , 16 12 octets ^SBCS

Fonction de préfixe tacite anonyme. 0 indexé.

+/⊢↑∘∊¯1,¨⍨⍳

Essayez-le en ligne!

+/ la somme de

⊢↑ la première n éléments

∘∊ du ϵ nlistés (aplatis)

¯1,¨⍨ négatif-un-apposé à chacun

⍳ premiers n ɩ ndices (0 à n–1

Gelée , 6 octets

HḶS‘_Ḃ

Un lien monadique acceptant (indexé 1) nqui revient a(n).

Essayez-le en ligne! Ou consultez la suite de tests

Comment?

HḶS‘_Ḃ - link: n
H      - halve         -> n/2.0
 Ḷ     - lowered range -> [0,1,2,...,floor(n/2.0)-1]
  S    - sum           -> TriangleNumber(floor(n/2.0)-1)
   ‘   - increment     -> TriangleNumber(floor(n/2.0)-1)+1
     Ḃ - bit = 1 if n is odd, 0 if it's even
    _  - subtract      -> TriangleNumber(floor(n/2.0)-1)+isEven(n)

PHP , 73 64 55 51 47 octets

Première méthode

Première réponse de golf de code!
Je suis sûr qu'il existe des astuces PHP pour le raccourcir et les mathématiques peuvent probablement être améliorées.

Prend n comme premier argument et sort le nième nombre de la séquence.

$y=$argv[1]/2;for(;$i<$y+1;)$x+=$i++;echo$x-($y|0);

Moins 9 octets en supprimant "$ x = 0;" et "$ i = 0".

Moins 9 octets grâce à @Kevin Cruijssen améliorant la boucle for et la perte de la balise de fin.

Moins 1 octet à l'aide de bits ou "|" plutôt que "(int)"

Moins 3 octets grâce à @Dennis car vous pouvez supprimer les balises en l'exécutant depuis la ligne de commande avec "php -r 'code here'"

Essayez-le en ligne!

Deuxième méthode

Correspond à ma réponse précédente avec une toute nouvelle méthode!

for(;$i<$argv[1];$i++)$x+=($y^=1)?$i/2+1:-1;echo$x;

Utiliser XOR et l'opérateur tenary pour basculer entre les sommes dans la boucle.

Edit: Cela ne fonctionne pas pour n = 0 et je n'ai aucune idée pourquoi. $ i n'est pas assigné, donc il devrait être 0, donc la boucle ($i<$argv[1])devrait échouer comme (0<0==false), donc un $ x non assigné devrait sortir comme 0 et non 1.

Essayez-le en ligne!

Troisième méthode

La conversion de la formule Excel @Wernisch créée en PHP donne une solution de 47 octets

$z=$argv[1];echo(pow($z,2)+(($z&1)?7:-2*$z))/8;

Essayez-le en ligne!

R , 35 octets

diffinv(rbind(n<-1:scan(),-1)[n-1])

Essayez-le en ligne!

Je pensais que c'était une alternative intéressante à la réponse de @ JayCe car elle ne portait pas très bien vers les langues sans support intégré pour les matrices, et se trouve être tout aussi golfique.

1 indexé, retourne les premiers néléments de la séquence.

Comment ça marche:

rbind(n<-1:scan(),-1) construit la matrice suivante:

     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4
[2,]   -1   -1   -1   -1

Parce que R contient les matrices dans l'ordre des colonnes, si nous devions convertir cela en a vector, nous obtiendrions un vecteur

1 -1 2 -1 3 -1 4 -1

qui si nous prenons une somme cumulée de, nous obtiendrions

1 0 2 1 4 3 7 6

qui est la séquence, juste sans le début 0. diffinvheureusement ajoute le zéro de tête, nous prenons donc les premières n-1valeurs de la matrice etdiffinv eux, en obtenant les premières nvaleurs de la séquence.

R , 35 34 octets

(u=(n=scan())-n%%2-1)-n+(15+u^2)/8

Essayez-le en ligne!

Première option de sortie.Même formule que beaucoup d'autres réponses (je voudrais pointer vers la première réponse fournissant la formule, je ne peux pas la comprendre).

Deuxième et troisième options de sortie ci-dessous:

R , 43 octets

function(m,n=1:m,u=n%%2+1)((n-u)^2-1)/8+2-u

Essayez-le en ligne!

R , 51 octets

while(T){cat(((T-(u=T%%2+1))^2-1)/8+2-u," ");T=T+1}

Essayez-le en ligne!

Matlab / Octave, 31 26 octets

5 octets enregistrés thx à Luis Mendo!

@(n)sum(1:n/2+.5)-fix(n/2)

Java (JDK 10) , 20 octets

x->x%2+(x=~-x|1)*x/8

Essayez-le en ligne!

Port de TFeld's Python 2 anwser , alors allez leur donner un upvote! ;)

QBasic 1.1 , 49 octets

INPUT N
R=1
FOR I=1TO N\2-1
R=R+I
NEXT
?R-N MOD 2

1 indexé.

QBasic 1.1 , 30 octets

INPUT N
?(N-1OR 1)^2\8+N MOD 2

Utilise l'algorithme de TFeld. 0 indexé.

QBasic, 31 octets

La solution «juste implémenter la spécification» est légèrement plus longue que la solution d' Erik .

DO
?n
i=i+1
n=n+i
?n
n=n-1
LOOP

Cela sort indéfiniment. Pour les exécuter, je recommande de changer la dernière ligne en quelque chose comme LOOP WHILE INPUT$(1) <> "q", qui attendra une pression de touche après chaque deuxième entrée de séquence et quittera si la touche enfoncée est q.

C # (.NET Core) , 56 octets

n=>{int a=0,i=0;for(;++i<n;)a+=i%2<1?-1:i/2+1;return a;}

-2 octets grâce à Kevin Crujssen

Essayez-le en ligne!

1 indexé. Résultatsa(n)

Non golfé:

int f(int n)
{
    // a needs to be outside the for loop's scope,
    // and it's golfier to also define i here
    int a = 0, i = 1;
    // basic for loop, no initializer because we already defined i
    for (; ++i < n;)
    {
        if (i%2 < 1) {
            // if i is even, subtract 1
            a -= 1;
        }
        else
        {
            // if i is odd, add (i / 2) + 1
            // this lets us handle X without defining another int
            a += i / 2 + 1;
        }
    }
    // a is the number at index n
    return a;
}

Husk , 11 9 8 octets

ΘṁṠe→Θ∫N

Enregistré un octet grâce à H.PWiz.
Sorties sous forme de liste infinie.
Essayez-le en ligne!

Explication

ΘṁṠe→Θ∫N
      ∫N   Cumulative sum of natural numbers (triangular numbers).
     Θ     Prepend 0.
 ṁṠe→      Concatenate [n + 1, n] for each.
Θ          Prepend 0.

Dodos , 69 octets

	. w
w
	. h
	+ r . ' dab h '
h
	h ' '
	. dab
r
	
	r dip
.
	dot
'
	dip

Essayez-le en ligne!

C'est en quelque sorte la réponse la plus longue.

Explication.

┌────┬─────────────────────────────────────────────────┐
│Name│Function                                         │
├────┼─────────────────────────────────────────────────┤
│.   │Alias for "dot", computes the sum.               │
├────┼─────────────────────────────────────────────────┤
│'   │Alias for "dip".                                 │
├────┼─────────────────────────────────────────────────┤
│r   │Range from 0 to n, reversed.                     │
├────┼─────────────────────────────────────────────────┤
│h   │Halve - return (n mod 2) followed by (n/2) zeros.│
└────┴─────────────────────────────────────────────────┘

Fusain , 15 octets

Ｉ∨ΣＥＮ⎇﹪ι²±¹⊕⊘ι⁰

Essayez-le en ligne! 0 indexé. Le lien est vers la version détaillée du code. La formule serait probablement plus courte, mais quel est le plaisir là-dedans? Explication:

    Ｎ           Input as a number
   Ｅ            Map over implicit range
     ⎇          Ternary
      ﹪ι²       Current value modulo 2
         ±¹     If true (odd) then -1
           ⊕⊘ι  Otherwise calculate X as i/2+1
  Σ             Take the sum
 ∨            ⁰ If the sum is empty then use zero
Ｉ               Cast to string and implicitly print

JavaScript, 49 48 45 octets

x=>eval('for(i=0,r=1;++i<x+2;)r+=i%2?-1:i/2')

Essayez-le en ligne!

Pas aussi jolie que la réponse @tsh, mais la mienne fonctionne pour un plus grand nombre.

Et maintenant merci @tsh, pour la evalsolution!

Befunge 93, 26 octets

<v0p030
 >:.130g+:30p+:.1-

Fonctionne indéfiniment
Essayez-le en ligne , bien que la sortie devienne un peu bancale et redescende après x = 256, TIO ne peut probablement pas gérer les caractères supérieurs à U + 256. Fonctionne très bien sur https://www.bedroomlan.org/tools/befunge-playground (Chrome uniquement, malheureusement. Avec Firefox, les lignes de fin sont supprimées au moment de l'exécution, pour une raison quelconque ...)

J , 17 octets

1#.[{._1,@,.~1+i.

Un port de la solution APL d'Adám.

Essayez-le en ligne!

Pyth , 8 octets

s<s,R_1S

Renvoie nle numéro de la séquence, indexé 0. Essayez-le en ligne

Explication, avec exemple pour n=5:

s<s,R_1SQQ   Final 2 Q's are implicit, Q=eval(input())

       SQ    1-indexed range        [1,2,3,4,5]
   ,R_1      Map each to [n,-1]     [[1,-1],[2,-1],[3,-1],[4,-1],[5,-1]]
  s          Sum (Flatten)          [1,-1,2,-1,3,-1,4,-1,5,-1]
 <       Q   Take 1st Q             [1,-1,2,-1,3]
s            Sum, implicit output   4

Perl 6 ,  38  26 octets

{(0,{$_+(($+^=1)??++$ !!-1)}...*)[$_]}

Essayez-le

{(+^-$_+|1)**2 div 8+$_%2}

Basé sur l'ingénierie inverse de la réponse Python de TFeld .
Essayez-le

Étendu

38 octets (générateur de séquence):

{  # bare block lambda with implicit parameter $_

  (
    # generate a new sequence everytime this function is called

    0,    # seed the sequence

    {     # bare block that is used to generate the rest of the values

      $_  # parameter to this inner block (previous value)

      +

      (
          # a statement that switches between (0,1) each time it is run
          ( $ +^= 1 )

        ??     # when it is 1 (truish)
          # a statement that increments each time it is run
          ++$ # &prefix:« ++ »( state $foo )

        !!     # or else subtract 1
          -1
      )
    }

    ...  # keep generating until:

    *    # never stop

  )[ $_ ] # index into the sequence
}

Notez que cela a l'avantage que vous pouvez transmettre * pour obtenir la séquence entière, ou transmettre une plage pour générer plus efficacement plusieurs valeurs.

26 octets (calcul direct):

{  # bare block lambda with implicit parameter $_

  (

    +^     # numeric binary negate
      -$_  # negative of the input
      +|   # numeric binary or
      1

  ) ** 2   # to the power of 2

  div 8     # integer divide it by 8

  + $_ % 2  # add one if it is odd
}

05AB1E , 8 octets

;L¨O>¹É-

Essayez-le en ligne!

Basé sur l'approche Jelly de Jonathan Allan (qui était probablement basée sur une modification de la question par OP avec une autre définition de la séquence), donc 1-indexé.

Convexe , 10 9 octets

_½,ª)\2%-

Essayez-le en ligne!

Basé sur l'approche Jelly de Jonathan Allan (qui était probablement basée sur une modification de la question par OP avec une autre définition de la séquence). 1 indexé.

Explication:

_½,ª)\2%- Stack: [A]
_         Duplicate. Stack: [A A]
 ½        Halve. Stack: [A [A]½]
  ,       Range, [0..⌊N⌋). Stack: [A [[A]½],]
   ª      Sum. Stack: [A [[A]½],]ª]
    )     Increment. Stack: [A [[[A]½],]ª])]
     \    Swap. Stack: [[[[A]½],]ª]) A]
      2   2. Stack: [[[[A]½],]ª]) A 2]
       %  Modulo. Stack: [[[[A]½],]ª]) [A 2]%]
        - Minus. Stack: [[[[[A]½],]ª]) [A 2]%]-]

Gelée , 6 octets

Renvoyez les premiers nchiffres.

Rj-ÄŻḣ

Essayez-le en ligne!