Aquí los primeros 100 números de una secuencia fácil:

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

¿Cómo funciona esta secuencia?

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
• Por cada impar n(0 indexado), es a(n-1) + X(donde X=1y aumenta en 1 cada vez que se accede)
• Por cada par n(0 indexado), esa(n-1) - 1

Reto:

Uno de:

• Dado un entero de entrada n, genera el n'número número en la secuencia.
• Dado un entero de entrada n, genera los primeros nnúmeros de la secuencia.
• Emite la secuencia indefinidamente sin tomar una entrada ( o tomar una entrada vacía sin usar ).

Reglas de desafío:

• La entrada npuede ser tanto 0 como 1 indexada.
• Si genera (parte de) la secuencia, puede usar una lista / matriz, imprimir en STDOUT con cualquier delimitador (espacio, coma, nueva línea, etc.). Tu llamada.
• Indique cuál de las tres opciones ha utilizado en su respuesta.
• Deberá admitir al menos los primeros 10,000 números (el número 10,000 es 12,497,501).

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de código. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es posible.

Casos de prueba:

Pastebin con los primeros 10,001 números en la secuencia. Siéntase libre de elegir cualquiera que desee.

Algunos números más altos:

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 bytes

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

Pruébalo en línea!

Devuelve el nnúmero 0-th ( -indexed)

Excel, 31 bytes

La respuesta está 0indexada. Emite nel número.

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

La secuencia descrita es, en última instancia, solo dos secuencias entrelazadas:

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

Entrelazar estos en una 0secuencia indexada da:

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

Lo que da:

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

que jugamos hasta los 31bytes.

Usando el mismo enfoque, 1indexado da 37bytes:

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

Jalea , 6 bytes

Rj-ḣ⁸S

Pruébalo en línea!

0 indexado. Devuelve el nnúmero

Explicación:

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 bytes

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

1 indexado. Pruébalo en línea!

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 bytes

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

Devuelve una lista infinita, ¡ pruébelo en línea!

Explicación

scanltiene tres argumentos f, inity xs( [ x ₀ , x ₁ ... ] ) y construye una nueva lista:

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

Configuramos init = 0y usamos el ($)operador de aplicación invertido (por lo tanto, aplica una _i a la función x _i ), ahora solo necesitamos una lista de funciones: la lista [1..]>>=(:[pred]).(+)es una lista infinita con las funciones correctas:

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

Alternativa interesante, 37 bytes.

flipteniendo el tipo (a -> b -> c) -> b -> a -> cque también podríamos usar en id :: d -> dlugar de ($)debido a la inferencia de tipos de Haskell con la dque se unificaría el tipo a -> b, dándonos lo mismo.

Pruébalo en línea!

Editar

^{-2 bytes utilizando en (>>=)lugar de do-notation.}

^{-1 byte usando en scanllugar de zipWith.}

Haskell , 25 bytes

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

Pruébalo en línea!

Construye una lista infinita.

Haskell , 27 bytes

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

Pruébalo en línea!

Haskell , 30 bytes

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

Pruébalo en línea!

05AB1E , 10 bytes

ÎF<NÈi¼¾>+

Pruébalo en línea!

Explicación

Î             # 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

Otro 10 byter: ÎFNÈN;Ì*<O

Octava , 32 bytes

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

Pruébalo en línea!

Emite el n-ésimo número, indexado a 0. Utiliza la misma fórmula que varias otras respuestas.

APL (Dyalog Unicode) , 16 12 bytes ^SBCS

Función de prefijo tácito anónimo. 0 indexado.

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

Pruébalo en línea!

+/ la suma de

⊢↑ los primeros nelementos

∘∊ de la ε nlisted (aplanada)

¯1,¨⍨ negativo-uno-añadido-a-cada

⍳ primeros n ɩ ndices (0 a n–1

Jalea , 6 bytes

HḶS‘_Ḃ

Un enlace monádico que acepta (1 indexado) nque devuelve a(n).

Pruébalo en línea! O ver el conjunto de pruebas

¿Cómo?

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 bytes

Primer metodo

Primer código de respuesta de golf!
Estoy seguro de que hay trucos PHP para hacerlo más corto y las matemáticas probablemente puedan mejorarse.

Toma n como primer argumento y genera el enésimo número en la secuencia.

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

Menos 9 bytes eliminando "$ x = 0;" y "$ i = 0".

Menos 9 bytes gracias a @Kevin Cruijssen que mejora el bucle for y la pérdida de la etiqueta final.

Menos 1 byte usando bitwise o "|" en lugar de "(int)"

Menos 3 bytes gracias a @Dennis, ya que puede eliminar las etiquetas ejecutándolas desde la línea de comandos con "php -r 'code here'"

Pruébalo en línea!

Segundo método

¡Emparejé mi respuesta anterior con un método completamente nuevo!

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

Usando XOR y el operador de tenary para cambiar entre sumas en el bucle.

Editar: Esto no funciona para n = 0 y no tengo idea de por qué. $ i no está asignado, por lo tanto, debería ser 0, por lo tanto, el bucle ($i<$argv[1])debería fallar como (0<0==false), por lo tanto, un $ x no asignado debería salir como 0 y no 1.

Pruébalo en línea!

Tercer método

La conversión de la fórmula de Excel @Wernisch creada a PHP proporciona una solución de 47 bytes

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

Pruébalo en línea!

R , 35 bytes

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

Pruébalo en línea!

Pensé que esta era una alternativa interesante a la respuesta de @ JayCe, ya que no se adapta muy bien a los idiomas sin soporte incorporado para las matrices, y resulta ser igual de interesante.

1 indexado, devuelve los primeros nelementos de la secuencia.

Cómo funciona:

rbind(n<-1:scan(),-1) construye la siguiente matriz:

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

Debido a que R contiene matrices en el orden de columna mayor, si tuviéramos que convertir esto en a vector, obtendríamos un vector

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

que si tomamos una suma acumulativa de, obtendríamos

1 0 2 1 4 3 7 6

cuál es la secuencia, solo que sin la guía 0. diffinvafortunadamente agrega el cero inicial, por lo que tomamos los primeros n-1valores de la matriz y diffinvlos obtenemos, obteniendo los primeros nvalores de la secuencia.

R , 35 34 bytes

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

Pruébalo en línea!

Primera opción de salida. La misma fórmula que muchas otras respuestas (me gustaría señalar la primera respuesta que proporciona la fórmula, no puedo entender cuál es).

Segunda y tercera opciones de salida a continuación:

R , 43 bytes

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

Pruébalo en línea!

R , 51 bytes

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

Pruébalo en línea!

Matlab / Octave, 31 26 bytes

¡5 bytes guardados gracias a Luis Mendo!

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

Java (JDK 10) , 20 bytes

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

Pruébalo en línea!

Respuesta del puerto de TFeld Python 2 , ¡así que ve a darles un voto positivo ! ;)

QBasic 1.1 , 49 bytes

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

1 indexado.

QBasic 1.1 , 30 bytes

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

Utiliza el algoritmo de TFeld. 0 indexado.

QBasic, 31 bytes

La solución solo implementar la especificación viene un poco más larga que la solución de Erik .

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

Esto sale indefinidamente. Con el fin de ejecutarlo, recomiendo cambiar la última línea a algo así LOOP WHILE INPUT$(1) <> "q", que esperará una pulsación de tecla después de cada segunda secuencia de entrada y saldrá si se pulsa la tecla q.

C # (.NET Core) , 56 bytes

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

-2 bytes gracias a Kevin Crujssen

Pruébalo en línea!

1 indexado. Devolucionesa(n)

Ungolf'd:

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

Casco , 11 9 8 bytes

ΘṁṠe→Θ∫N

Guardado un byte gracias a H.PWiz.
Salidas como una lista infinita.
Pruébalo en línea!

Explicación

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

Dodos , 69 bytes

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

Pruébalo en línea!

De alguna manera esta es la respuesta más larga.

Explicación.

┌────┬─────────────────────────────────────────────────┐
│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.│
└────┴─────────────────────────────────────────────────┘

Carbón de leña , 15 bytes

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

Pruébalo en línea! 0 indexado. El enlace es a la versión detallada del código. La fórmula probablemente sería más corta, pero ¿cuál es la diversión en eso? Explicación:

    Ｎ           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 bytes

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

Pruébalo en línea!

No es tan bonito como @tsh answer, pero el mío funciona para números más grandes.

Y ahora gracias @tsh, ¡por la evalsolución!

Befunge 93, 26 bytes

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

Se ejecuta indefinidamente
Pruébelo en línea , aunque la salida se vuelve un poco inestable y vuelve a bajar después de x = 256, presumiblemente TIO no puede manejar caracteres por encima de U + 256. Funciona bien en https://www.bedroomlan.org/tools/befunge-playground (Chrome solo, desafortunadamente. Con Firefox, las líneas finales se eliminan en tiempo de ejecución, por alguna razón ...)

J , 17 bytes

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

Un puerto de la solución APL de Adám.

Pruébalo en línea!

Pyth , 8 bytes

s<s,R_1S

Devuelve el nnúmero th en la secuencia, indexado a 0. Pruébalo en línea

Explicación, con ejemplo para 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 bytes

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

Intentalo

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

Basado en la ingeniería inversa de la respuesta Python de TFeld .
Intentalo

Expandido

38 bytes (generador de secuencia):

{  # 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
}

Tenga en cuenta que esto tiene el beneficio que puede pasar * para obtener la secuencia completa, o pasar un Rango para generar de manera más eficiente múltiples valores.

26 bytes (cálculo directo):

{  # 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 bytes

;L¨O>¹É-

Pruébalo en línea!

Basado en el enfoque Jelly de Jonathan Allan (que probablemente se basó en la edición de OP de la pregunta con otra definición de la secuencia), por lo que se indizó en 1.

Convexo , 10 9 bytes

_½,ª)\2%-

Pruébalo en línea!

Basado en el enfoque Jelly de Jonathan Allan (que probablemente se basó en la edición de OP de la pregunta con otra definición de la secuencia). 1 indexado.

Explicación:

_½,ª)\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]%]-]

Jalea , 6 bytes

Devuelve los primeros nnúmeros.

Rj-ÄŻḣ

Pruébalo en línea!