Enumeración de enteros mareados

25

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!

code-golf  sequence  integer 
— Pavel
fuente
— sergiol
Parece lo
— contrario

Respuestas:

8

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     »     ±      .     »    ⌡
— dzaima
fuente
3
¡NO TOMÓ UN SOLO MINUTO!
— NieDzejkob
66
Yo ».»estoy en el teléfono I».»⌡±.
— Jonathan Allan
@ JonathanAllan No lo entiendo ._.
— Pavel
4

C, 25 bytes

f(n){return~n/2*~-(n&2);}
— orlp
fuente
Puede guardar 4 bytes asignando su valor de retorno al primer parámetro en lugar de usar la palabra clave return. f(n){n=~n/2*~-(n&2);}
— cleblanc
55
@cleblanc Así no es como funciona C.
— orlp
2
gcc -O0para x86-64 compila la versión de @ cleblanc con instrucciones que dejan el resultado de multiplicación en eax( godbolt.org/g/dztKPV ), pero entonces sería una x86-64 gcc -O0respuesta, no una respuesta de C. No voto a favor las respuestas de C que rompen con la optimización habilitada, especialmente no esa estúpida última expresión como basura de valor de retorno. Incluso si así es como funciona gcc, no es así como funciona C.
— Peter Cordes
Hacer un puntero. No necesita optimizaciones si los valores originales y finales no están en la pila.
— mreff555
1
@ mreff555 Ese sería un método de E / S no estándar (aunque aceptable), y no sería más corto.
— orlp
3

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.

— Sr. Xcoder
fuente
3

Mathematica, 24 bytes

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

-14 bytes de @Misha Lavrov

— J42161217
fuente
1
Usar Booley OddQtiene el efecto de convertir números impares a 1 y números pares a 0, pero no necesita eso aquí: las potencias de -1 le dan la respuesta correcta para todos los números impares de todos modos. Entonces puede reducir ese paso (-1)^Tr@{#,s}o simplemente (-1)^(#+s).
— Misha Lavrov
2

Lote, 29 bytes

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

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
Expandir fragmento

0 indexado.

— Neil
fuente
2

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
— usuario202729
fuente
2

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
— pizzapants184
fuente
2

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
— Kevin Cruijssen
fuente
2

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.

<>{}{<>([{}])(<>)}<>
— Asistente de trigo
fuente
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
— Steenbergh
fuente
1

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))
— Bob Jarvis - Restablece a Monica
fuente
1

Excel VBA de 32 bits, 39 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)

— Taylor Scott
fuente
¿Es el espacio entre (-1)y ^[Intnecesario?
— Pavel
@Pavel al menos para la versión de 64 bits de Excel VBA, sí; Pero dicho esto, juro que no es para la versión de 32 bits, pero lamentablemente no puedo probar eso en ninguno de los equipos que tengo a mano
— Taylor Scott
@Pavel: lo he visto en un sistema de 32 bits (especificación de instalación predeterminada) y en ese sistema no se requiere espacio; he restringido la solución a 32 bits para aprovechar esto
— Taylor Scott,
1
¡Guay! Sin embargo, olvidó agregar el recuento de bytes corregido.
— Pavel
Whoops, gracias @Pavel - Ya está arreglado
— Taylor Scott
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.