Su desafío hoy es generar un término dado de una secuencia que enumere todos los enteros. La secuencia es la siguiente: si tenemos una función indexada en 0 que genera la secuencia f(n)y ceil(x)es la función de techo, entonces f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))es positivo cuando ny ceil(n/2)son pares o impares.

Para ayudar a comprender esta secuencia, los primeros términos son los siguientes: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Su tarea es escribir un programa que tome un número entero ny genere el ntérmino de la secuencia. La entrada puede ser solo 0 o 1 indexada.

Casos de prueba (indexados a 0):

0  =>  0
1  =>  1
2  => -1
3  => -2
4  =>  2
5  =>  3

Este es el código de golf , ¡la menor cantidad de bytes gana!

SOGL V0.12 , 8 6 bytes

I».»⌡±

Pruébalo aquí! o pruebe los primeros dos números (cambiado un poco para que funcione)
indexado en 0.

Explicación:

I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

O más simple:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡

Python 2 , 26 24 bytes

lambda x:-~x/2/(1-(x&2))

Pruébalo en línea!

JavaScript (ES6), 18 bytes

1 indexado.

n=>n/(++n&2||-2)|0

Manifestación

let f =

n=>n/(++n&2||-2)|0

for(n = 1; n < 20; n++) {
  console.log(n + ' --> ' + f(n))
}

C, 25 bytes

f(n){return~n/2*~-(n&2);}

Haskell , 26 bytes

f x=div(x+1)2*(-1)^div x 2

Pruébalo en línea!

Las otras respuestas de Haskell parecen ser demasiado complicadas ... ^^

Pyke , 6 bytes

heQeV_

Pruébalo aquí!

Utiliza el enfoque de dzaima ... Beats Ties Jelly!

Explicación

h      - Increment the input, which is implicit at the beginning.
 e     - Floor halve.
  Q    - Push the input.
   e   - Floor halve.
    V_ - Apply repeatedly (V), ^ times, using negation (_).
       - Output implicitly.

Los bytes hexadecimales codificados equivalentes serían: 68 65 51 65 56 5F.

Jalea , 6 bytes

HµĊN⁸¡

Pruébalo en línea!

Utiliza el algoritmo de dzaima.

-1 gracias a Jonathan Allan .

Python 2 , 21 bytes

lambda x:-x/2*~-(x&2)

Pruébalo en línea!

Mathematica, 24 bytes

(s=⌈#/2⌉)(-1)^(#+s)&  

-14 bytes de @Misha Lavrov

Haskell , 25 43 42 bytes

((do a<-[0..];[[-a,a],[a,-a]]!!mod a 2)!!)

Pruébalo en línea! 1 indexado.

Editar: La versión anterior tenía los signos en un orden incorrecto, gracias a @ Potato44 por señalarlo. Corregido por 18 bytes ...

Edición 2: ¡ Gracias a BMO por -1 byte!

Python 3 , 29 bytes

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

Pruébalo en línea!

Pyth , 9 bytes

_F/hQ2/Q2

Pruébalo aquí!

Utiliza el enfoque de dzaima .

Haskell, 36 bytes

g x=x: -x:g(-x-signum x)
((0:g 1)!!)

Pruébalo en línea!

05AB1E , 6 bytes

;DîsF(

Pruébalo en línea!

Utiliza el algoritmo de dzaima.

Lote, 29 bytes

@cmd/cset/a"%1/2^(%1<<30>>30)

JavaScript (ES6), 18 bytes

f=
n=>n/2^(n<<30>>30)

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

0 indexado.

Javascript, 17 bytes

n=>~n/2*~-(n&2)^0

f=
n=>~n/2*~-(n&2)^0

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

Este es 0 indexado. Es un truco totalmente bit a bit.

Cúbicamente , 23 bytes

(1 indexado)

FDF'$:7+8/0_0*0-8*7/0%6

Pruébalo en línea!

La principal dificultad al escribir código en Cubically son:

• Solo hay 1 variable que se puede escribir, y
• Obtener constantes es difícil.

Entonces, esta solución calcula

((((n+1)/2)%2)*2-1)*n/2

donde /denota división entera. Eso solo necesita 1 variable temporal, y las constantes 1 y 2.

Explicación:

FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print

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

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

Un programa completo que se llama like 5:prgmNAME.

TI-Basic es un idioma tokenizado , todos los tokens utilizados aquí son de un byte, excepto el remainder(que es dos.‾representa el token regativo, que se escribe con la (-)clave.

Ejemplos:

0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

Explicación:

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Misma fórmula que una función Y-var:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2

dc , 16 bytes

1+d2~+2%2*1-r2/*

Estoy seguro de que hay una manera de hacer 0..1 a -1..1 en CC más corto, pero no tengo ideas por ahora.

Pruébalo en línea!

Java 8, 15 bytes

n->~n/2*~-(n&2)

EDITAR: ¿Es Java realmente el más corto de los lenguajes que no son de golf? o.Ô

Explicación:

Pruébalo aquí.

Usaré la tabla a continuación como referencia de lo que está sucediendo.

1. ~n es igual a -n-1 .
2. Dado que la división de enteros en Java se basa automáticamente en enteros positivos y se limita a enteros negativos, ~n/2dará como resultado la secuencia0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
3. n&2resultará en cualquiera 0o 2, en la secuencia0,0,2,2,0,0,2,2,0,0,2,...
4. ~-xes igual a (x-1), entonces ~-(n&2)( ((n&2)-1)) resulta en la secuencia-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
5. Multiplicar las dos secuencias de ~n/2y ~-(n&2)give es la secuencia correcta que se pide en el desafío:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Tabla de resumen:

n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5

Brain-Flak , 86 74 72 70 bytes

{({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}<>{}{<>([{}])(<>)}<>

Pruébalo en línea!

Explicación

Hay dos partes en este código. La primera parte

({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}

hace la fuerza de la computación. Determinaceil(n/2) y si se niega o no la salida.

Para explicar cómo funciona, primero explicaré cómo se calcularía ceil(n/2). Esto podría hacerse con el siguiente código

{({}[()]<({}([{}]()))>)}{}

Esto cuenta hacia atrás desde n cada vez que realiza un not (([{}]()) ) en un contador y agrega el contador a un resultado. Dado que el contador es cero la mitad del tiempo, solo incrementamos cada dos carreras comenzando con la primera.

Ahora quiero calcular también el signo de nuestros resultados. Para hacer esto comenzamos otro contador. Este contador solo cambia de estado si el primer contador está apagado. De esa manera obtenemos el patrón deseado. Ponemos estos dos contadores en la pila de fichas para facilitar el movimiento cuando llegue el momento.

Ahora, una vez que hemos terminado ese cálculo, nuestra pila se ve así

          parity(n)
ceil(n/2) sign

Por lo tanto, tenemos que trabajar un poco para obtener el resultado deseado en esta segunda parte.

<>{}{<>([{}])(<>)}<>

Perl 5 , 32 + 1 ( -p) = 33 bytes

$_='-'x(($_+++($b=0|$_/2))%2).$b

Pruébalo en línea!

Protón , 23 bytes

n=>-~n//2//(-1)**(n//2)

Pruébalo en línea!

La solución del puerto de Halvard .

Protón , 23 bytes

n=>-~n//2*(-1)**(n%4>1)

Pruébalo en línea!

Solución del puerto de Leaky .

Un poco más Protonic, 24 bytes:

n=>-~n//2*(**)(-1,n%4>1)

QBIC , 27 26 bytes

g=(:+1)'\2`~(a-g)%2|?-g\?g

Explicación

g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g

Clojure 122 bytes

Detallado, incluso cuando se juega al golf. Voy por el voto de simpatía aquí ... :-)

Golfizado:

(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Sin golf:

(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))

Excel VBA de 32 bits, ₃₉ 37 bytes

Función de ventana inmediata anónima de VBE que toma la entrada de la celda A1y las salidas a la ventana inmediata de VBE

?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

Restringido a 32 bits, ya A^Bque no es válido en 64 bits ( A ^Bestá lo más cerca posible)

Julia 0.6 , 16 bytes

Es solo la solución de Java, excepto que necesito ÷una división entera.

n->~n÷2*~-(n&2)

Pruébalo en línea!