Dado N, genera el enésimo término de esta secuencia infinita:

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ... etc.

N puede estar indexado 0 o indexado 1 como desee.

Por ejemplo, si 0-indexado entonces entradas 0, 1, 2, 3, 4debe producir salidas respectivas -1, 2, -2, 1, -3.

Si 1 indexados entonces entradas 1, 2, 3, 4, 5debe producir salidas respectivas -1, 2, -2, 1, -3.

Para ser claros, esta secuencia se genera tomando la secuencia de enteros positivos repetidos dos veces

1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ...

y reorganizando cada par de números impares para rodear los números pares justo encima de él

1 2 2 1 3 4 4 3 5 6 6 5 7 8 8 7 9 10 10 9 11 12 12 11 ...

y finalmente negando cualquier otro término, comenzando con el primero

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ...

El código más corto en bytes gana.

Python 2 , 23 bytes

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

Las entradas impares dan aproximadamente n/2, incluso las aproximadamente -n/2. Entonces, comencé -n/2+n%2*ny ajusté desde allí.

Pruébalo en línea!

Mathematica, 29 bytes

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

Función pura que toma una entrada indexada 1. Aparte de los signos alternos (-1)^#, el doble de la secuencia está cerca de la entrada, siendo las diferencias 1, 2, 1, -2 cíclicamente. Es bueno que #~GCD~4, el mayor divisor común de la entrada y 4, sea 1, 2, 1, 4 cíclicamente; así que simplemente lo reemplazamos manualmente 4->-2y lo llamamos un día. Me gusta este enfoque porque evita la mayoría de los comandos de Mathematica de muchos caracteres.

Pip , 24 22 bytes

v**a*YaBA2|1+:--a//4*2

Toma entrada, indexada en 1, como argumento de línea de comando. Pruébelo en línea o verifique 1-20 .

Explicación

Observe que la secuencia se puede obtener combinando otras tres secuencias, una de índice cero y las otras de índice uno:

• Comience con 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(0 indexado);
• Add 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, donde BAes AND a nivel de bit, y |es OR lógico (1 indexado);
• Multiplique la suma por -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1 indexado).

Si comenzamos con a1 indexado, podemos calcular primero las partes indexadas 1 (leyendo la expresión de izquierda a derecha) y luego disminuir apara la parte indexada 0. Usando la variable incorporada v=-1, obtenemos

v**a*((aBA2|1)+--a//4*2)

Para reducir dos bytes más, tenemos que usar algunos trucos de manipulación de precedencia. Podemos eliminar los paréntesis internos reemplazando +con+: (equivalente a +=en muchos idiomas). Cualquier operador de cálculo y asignación tiene muy poca prioridad, por lo que aBA2|1+:--a//4*2es equivalente a(aBA2|1)+:(--a//4*2) . Pip emitirá una advertencia sobre la asignación de algo que no es una variable, pero solo si tenemos habilitadas las advertencias.

Lo único que tiene una precedencia menor que :es Y, el operador de extracción. * Asigna el valor de su operando ay variable y lo pasa sin cambios; por lo que podemos eliminar los paréntesis exteriores, así como dando un tirón el valor en lugar de parenthesizing que: YaBA2|1+:--a//4*2.

_{* rint Py Output tienen la misma precedencia que Yank, pero no son útiles aquí.}

Jalea , 8 7 bytes

H^Ḃ~N⁸¡

Esto utiliza el algoritmo de mi respuesta de Python , que fue mejorado significativamente por @GB .

Pruébalo en línea!

Cómo funciona

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.

Java 8, 19 bytes

n->~(n/2)+n%2*(n|2)

Java 7, 47 37 bytes

int c(int n){return~(n/2)+n%2*(n|2);}

La primera vez que Java (8) realmente compite y es más corta que algunas otras respuestas. Sin embargo, todavía no puedo superar los idiomas de golf reales como Jelly y similares (duhuh ... qué sorpresa ...>.>; P)

Puerto indexado 0 de la respuesta Python 2 de @Xnor .
-10 bytes gracias a @GB

Pruébalo aquí

Jalea , 15 12 11 bytes

Ḷ^1‘ż@N€Fị@

Pruébalo en línea!

Cómo funciona

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.

RProgN 2 , 31 25 22 bytes

nx=x2÷1x4%{+$-1x^*}#-?

Explicado

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

Pruébalo en línea!

Rubí, 26 23 18 bytes

->n{~n/2+n%2*n|=2}

Basado en 0

-3 bytes robando la idea -1 ^ n de Greg Martin , Dennis y tal vez alguien más, luego -5 bytes robando la idea n | 2 de xnor .

Apilado , 30 28 bytes

:2%([:2/\4%2=tmo+][1+2/_])\#

Pruébalo en línea! Devuelve una función, que según lo permitido por meta consenso. . Toma información desde la parte superior de la pila.

Usando el mismo enfoque que la respuesta RProgN 2 .

Alternativamente, 46 bytes. Pruébalo en línea! :

{!()1[::1+,:rev,\srev\,\2+]n*@.n 1-#n 2%tmo*_}

Éste genera el rango y luego selecciona y niega el miembro según corresponda.

Python 2 ,  44  33 27 bytes

lambda n:(-1)**n*~(n/2^n%2)

¡Gracias a @GB por jugar golf en 6 bytes!

Pruébalo en línea!

05AB1E, 8 bytes

2‰`^±¹F(

Pruébalo en línea

Explicación

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate

Jalea , 9 8 bytes

|2×Ḃ+H~$

Pruébalo en línea!

-1 gracias a Dennis . Duh flotan conversiones.

Utiliza el enfoque Python 2 de @ xnor.

EDITAR : > _>

CJam , 16 bytes

{_(_1&)^2/)W@#*}

Entrada basada en 1.

Pruébalo en línea!

Explicación

Aquí hay un desglose del código con los valores en la pila para cada entrada de 1a 4. Los primeros comandos sólo afectan a los dos bits menos significativos de n-1lo que después 4, esto simplemente repite cíclicamente, con los resultados incrementa en 2, debido a la reducción a la mitad.

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]

Perl 6 ,  55 27 24  22 bytes

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

(Inspirado por la zipWithrespuesta de Haskell )
Pruébalo

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

(Inspirado por varias respuestas)
Pruébalo

{+^($_+>1)+$_%2*($_+|2)}

Intentalo

{+^$_+>1+$_%2*($_+|2)}

Intentalo

Expandido:

{  # bare block lambda with implicit parameter ｢$_｣

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

(Todos están basados ​​en 0)

Haskell , 37 36 bytes

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

Pruébalo en línea! Esta es una función anónima que toma un número ncomo argumento y devuelve el nelemento th de la secuencia indexado en 0 .

Haskell, 56 bytes

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

0 indexado

Perl 5 47 + 1 (para bandera) = 48 Bytes

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

Envío anterior 82 bytes

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

Corre así:

perl -n <name of file storing script>  <<<  n

JavaScript (ES7), 28 bytes

n=>(n+2>>2)*2*(-1)**n-!(n&2)

1 indexado. Todavía no he visto ninguna otra respuesta, así que no sé si este es el mejor algoritmo, pero sospecho que no.

JavaScript, 28 22 bytes

Gracias @ETHproductions por jugar golf en 6 bytes

x=>x%2?~x>>1:x%4+x/2-1

Pruébalo en línea!

dc , 98 bytes

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

Gosh, esta es la respuesta más larga aquí, principalmente porque seguí el camino de generar el valor absoluto de cada elemento de la secuencia uno por uno en base a la siguiente fórmula recursiva:

luego generar (-1)^n * a_n, en lugar de calcular directamente el nelemento 'th. De todos modos, esto está 1indexado.

Pruébalo en línea!

R, 38 bytes

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

Explicación

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)

TI-Basic (TI-84 Plus CE), 31 bytes

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

TI-Basic es un lenguaje tokenizado y cada token utilizado aquí es un byte, excepto remainder(, que es dos.

Esto utiliza la versión 1 indexada.

Explicación:

Hay un patrón que se repite cada cuatro números. En la versión indexada 1, es: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 para el valor de entrada x. Esto se puede representar como una función definida por partes.

f (x) = - (x + 1) / 2 si x ≡ 1 mod 4; (x + 1) / 2 si x ≡ 2 mod 4; - (x + 1) / 2 si x ≡ 3 mod 4; (x-1) / 2 si x ≡ 0 mod 4

Debido a que las partes "x ≡ 1 mod 4" y "x ≡ 3 mod 4" son las mismas, podemos combinarlas en "x ≡ 1 mod 2".

Ahora la función por partes es:

f (x) = - (x + 1) / 2 si x ≡ 1 mod 2; (x + 2) / 2 si x ≡ 2 mod 4; (x-2) / 2 si x ≡ 0 mod 4

Aquí es donde empiezo a dividirlo en comandos reales. Como el valor es positivo para los índices pares y negativo para los impares, podemos usar (-1) ^ x. Sin embargo, en TI-Basic i^(2X(5 bytes) es más corto que(-1)^Ans (6 bytes). Tenga en cuenta que los paréntesis son obligatorios debido al orden de las operaciones.

Ahora que tenemos la manera de negar las entradas impares, pasamos a las modificaciones (agregando la negación de nuevo más adelante). Hice el caso de una entrada impar por defecto, así que comenzamos con .5(Ans+1).

Para arreglar el caso de una entrada uniforme, simplemente agregue uno al número entre paréntesis, pero solo cuando x ≡ 0 mod 2. Esto podría representarse como .5(Ans+1+remainder(Ans+1,2))o .5(Ans+1+not(remainder(Ans,2))), pero tienen el mismo número de bytes, por lo que no importa cuál.

Para arreglar el caso de entrada de múltiplo de 4, necesitamos restar 3 del número entre paréntesis, pero también otro 1 porque todos los múltiplos de 4 son pares, lo que sumaría uno de nuestro paso anterior, por lo que ahora tenemos .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))) .

Ahora, simplemente agregue la parte que determina la señal hasta el final para obtener el programa completo.

Befunge 93, 25 bytes

Indexado a cero

&4/2*1+&4%3%!!+&2%2*1-*.@

Pruébalo en línea!

El número viene dado por ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

QBIC , 53 bytes

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

Explicación:

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.

Sabio , 19 bytes

::>!:><^^~![!-!-~]|

Pruébalo en línea!

Este es solo un puerto de la respuesta de @Dennis 'Jelly a Wise.

Q, 52 bytes

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

0 solución indexada.

1. Obtiene el número de bloque, es decir. cuál bloque [-x x + 1 - (x + 1) x] dentro de la secuencia contiene el índice.
2. Obtiene el índice del valor dentro del bloque en función del índice del valor dentro de toda la secuencia.
3. Crea el bloque.
4. Índices en él a través del índice derivado en el paso 2.