La secuencia de la curva del dragón (o la secuencia de plegado de papel normal) es una secuencia binaria. a(n)está dado por la negación del bit restante del 1 menos significativo de n. Por ejemplo, para calcular a(2136)primero convertimos a binario:

100001011000

Encontramos nuestro bit menos significativo

100001011000
        ^

Toma el bit a su izquierda

100001011000
       ^

Y devuelve su negación

0

Tarea

Dado un entero positivo como entrada, salida a(n). (Puede generar por entero o por booleano). Debe intentar que su código sea lo más pequeño posible medido por bytes.

Casos de prueba

Aquí están las primeras 100 entradas en orden

1 1 0 1 1 0 0 1 1 1 0 0 1 0 0 1 1 1 0 1 1 0 0 0 1 1 0 0 1 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 0 0 0 1 1 0 1 1 0 0 0 1 1 0 0 1 0 0 1 1 1 0 1 1 0 0 1 1 1 0 0 1 0 0 1 1 1 0 1 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 1

Mathematica 25 Bytes

1/2+JacobiSymbol[-1,#]/2&

Otras formas de hacer esto:

56 bytes

(v:=1-IntegerDigits[#,2,i][[1]];For[i=1,v>0,i++];i++;v)&

58 bytes

1-Nest[Join[#,{0},Reverse[1-#]]&,{0},Floor@Log[2,#]][[#]]&

Python 3 , 22 21 bytes

1 byte gracias a ETHproductions.

lambda n:n&2*(n&-n)<1

Pruébalo en línea!

Bitwise aritmética ftw.

retina ,38 34 29 bytes

\d+
$*
+`^(1+)\1$|1111
$1
^1$

Pruébalo en línea!

A Martin y Leaky se les ocurrió esta idea, ¡con 5 bytes más de descuento!

Convierte la entrada en unaria, y luego divide progresivamente el número por 2. Una vez que ya no puede hacerlo de manera uniforme (es decir, el número es impar), elimina los parches de 4 de la entrada, calculando el resultado de la última operación mod 4 Finalmente, esto verifica si el resultado fue 1, lo que significa que el dígito a la izquierda del 1 bit menos significativo fue cero. Si eso es cierto, el resultado final es 1, de lo contrario es cero.

Jalea , 5 bytes

&N&HṆ

Pruébalo en línea!

Cómo funciona

&N&HṆ  Main link. Argument: n

 N     Negate; yield -n.
&      Bitwise AND; compute n&-n.
       This yields the highest power of 2 that divides n evenly.
   H   Halve; yield n/2.
  &    Bitwise AND; compute n&-n&n/2. This rounds n/2 down if n is odd.
    Ṇ  Take the logical NOT of the result.

Alice , 8 bytes

I2z1xnO@

Pruébalo en línea!

Toma la entrada como el punto de código de un carácter Unicode y genera el resultado como un byte 0x00 o 0x01 en consecuencia.

Para verificar, aquí hay una versión decimal de E / S de 12 bytes que usa exactamente el mismo algoritmo (solo E / S es diferente):

/o
\i@/2z1xn

Pruébalo en línea!

Si Alice era un lenguaje de golf y no requería E / S explícita y terminación del programa, esto se 2z1xnregistraría en solo 5 bytes ( ) superando tanto a 05AB1E como a Jelly.

Explicación

I    Read input.
2z   Drop all factors of 2 from the input, i.e. divide it by 2 as long
     as its even. This shifts the binary representation to the right
     until there are no more trailing zeros.
1x   Extract the second-least significant bit.
n    Negate it.
O    Output it.
@    Terminate the program.

05AB1E , 6 bytes

b0ܨθ≠

Pruébalo en línea!

Sabio , 28 20 16 bytes

::-~^~-&:[?>]~-^

Pruébalo en línea!

Explicación

Este es un puerto de la respuesta Python de Leaky Nun. Desafortunadamente, no funciona en TIO porque la versión de TIO del intérprete está un poco desactualizada.

Comenzamos haciendo 3 copias de nuestra entrada con ::, luego disminuimos la copia superior en 1. Esto cambiará todos los bits hacia arriba hasta el primer 1. Luego lo enviaremos a otra copia de nuestra entrada. Dado que todos los bits hasta el primer 1 en nuestra entrada se han invertido, esto dará como resultado que todos esos bits sean 1 en el resultado. Si luego agregamos uno ~-al resultado, obtendremos un solo 1 en el lugar a la izquierda de nuestro menos significativo 1. Nosotros Y esto con la entrada para obtener ese bit de la entrada. Ahora tendremos 0si ese bit estaba apagado y una potencia de 2 si ese bit estaba encendido, podemos cambiar esto en un solo 1o 0con :[?>]. Una vez hecho esto, solo necesitamos negar el bit ~-^y listo.

Python 2 , 19 bytes

lambda n:n&-n&n/2<1

Pruébalo en línea!

Haskell , 45 43 39 bytes

6 bytes guardados gracias a nimi

f x|d<-div x 2=[f d,mod(1+d)2]!!mod x 2

Pruébalo en línea!

Código de máquina x86, 17 16 15 bytes:

Asume un ABI donde los parámetros se insertan en la pila y el valor de retorno está en el ALregistro.

8B 44 24 04 0F BC C8 41 0F BB C8 0F 93 C0 C3

Esto se desmonta de la siguiente manera:

_dragoncurve:
  00000000: 8B 44 24 04        mov         eax,dword ptr [esp+4]
  00000004: 0F BC C8           bsf         ecx,eax
  00000007: 41                 inc         ecx
  00000008: 0F BB C8           btc         eax,ecx
  0000000B: 0F 93 C0           setae       al
  0000000E: C3                 ret

JavaScript (ES6), 17 14 bytes

f=
n=>!(n&-n&n/2)

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

Editar: ahorré 3 bytes al portar la respuesta de @ Dennis una vez que noté que la salida booleana era aceptable.

C (gcc) , 20 bytes

f(n){n=!(n&-n&n/2);}

Pruébalo en línea!

INTERCAL , 50 bytes

DOWRITEIN.1DO.1<-!?1~.1'~#1DOREADOUT.1PLEASEGIVEUP

Los operadores unarios de INTERCAL son bastante adecuados para esto, así que decidí escribir mi primera publicación.

DO WRITE IN .1
DO .1 <- !?1~.1'~#1
DO READ OUT .1
PLEASE GIVE UP

Haskell , 33 bytes

g~(a:b:c)=1:a:0:b:g c
d=g d
(d!!)

Pruébalo en línea!

Utiliza indexación 0.

Jalea , 7 6 bytes

1 byte gracias a Erik the Outgolfer.

Bt0ṖṪṆ

Pruébalo en línea!

Programas más largos

• 7 bytes: Họ¡2&2Ị
• 7 bytes: Bt0ṫ-ḄỊ

,,, , 10 9 bytes

::0-&2*&¬

Explicación

Tome la entrada como 3 por ejemplo.

::0-&2*&1≥
               implicitly push command line argument       [3]
::             duplicate twice                             [3, 3, 3]
  0            push 0 on to the stack                      [3, 3, 3, 0]
   -           pop 0 and 3 and push 0 - 3                  [3, 3, -3]
    &          pop -3 and 3 and push -3 & 3 (bitwise AND)  [3, 1]
     2         push 2 on to the stack                      [3, 1, 2]
      *        pop 2 and 1 and push 2 * 1                  [3, 2]
       &       pop 2 and 3 and push 2 & 3                  [2]
        ¬      pop 2 and push ¬ 2 (logical NOT)            [0]
               implicit output                             []

Haskell , 26 bytes

f n=even$div n$2*gcd(2^n)n

Pruébalo en línea!

Salida booleana.

Octava , 34 bytes

@(x)~(k=[de2bi(x),0])(find(k,1)+1)

Pruébalo en línea!

Explicación:

@(x)                               % Anonymous function taking a decimal number as input
    ~....                          % Negate whatever comes next
     (   de2bi(x)   )              % Convert x to a binary array that's conveniently 
                                   % ordered with the least significant bits first
        [de2bi(x),0]               % Append a zero to the end, to avoid out of bound index
     (k=[de2bi(x),0])              % Store the vector as a variable 'k'
                     (find(k,1)    % Find the first '1' in k (the least significant 1-bit)
                               +1  % Add 1 to the index to get the next bit
     (k=[de2bi(x),0])(find(k,1)+1) % Use as index to the vector k to get the correct bit

Sumisión:

Python 2 , 41 39 bytes

x=input()
while~-x&1:x/=2
print 1-x/2%2

Pruébalo en línea!

-2 bytes gracias a FryAmTheEggman

Solución inicial

Python 2 , 43 bytes

lambda x:1-int(bin(x)[bin(x).rfind('1')-1])

Pruébalo en línea!

MATL , 11 10 bytes

t4*YF1)Z.~

Pruébalo en línea! O vea las primeras 100 salidas .

Explicación

t    % Implicit input. Duplicate
4*   % Multiply by 4. This ensures that the input is a multiple of 2, and
     % takes into account that bit positions are 1 based
YF   % Exponents of prime factorization
1)   % Get first exponent, which is that of factor 2
Z.   % Get bit of input at that (1-based) position
~    % Negate. Implicit display

Pari / GP , 20 bytes

n->kronecker(-1,n)>0

Utilizando la símbolo de Kronecker .

Pruébalo en línea!

Befunge-98 , 19 bytes

&#;:2%\2/\#;_;@.!%2

Pruébalo en línea!

&#                       Initial input: Read a number an skip the next command
  ;:2%\2/\#;_;           Main loop: (Direction: East)
   :2%                    Duplicate the current number and read the last bit
      \2/                 Swap the first two items on stack (last bit and number)
                          and divide the number by two => remove last bit
         \                swap last bit and number again
          #;_;            If the last bit is 0, keep going East and jump to the beginning of the loop
                          If the last bit is 1, turn West and jump to the beginning of the loop, but in a different direction.
&#;           @.!%2      End: (Direction: West)
&#                        Jump over the input, wrap around
                 %2       Take the number mod 2 => read the last bit
               .!         Negate the bit and print as a number
              @          Terminate

SCALA, 99 (78?) Caracteres, 99 (78?) Bytes

if(i==0)print(1)else
print(if(('0'+i.toBinaryString).reverse.dropWhile(x=>x=='0')(1)=='1')0 else 1)

donde iesta la entrada

Como puede ver, guardo 21 bytes si no me ocupo del cero (como lo hizo el autor en su caso de prueba):

print(if(('0'+i.toBinaryString).reverse.dropWhile(x=>x=='0')(1)=='1')0 else 1)

Este es mi primer codegolf, así que espero haberlo hecho bien :)

Pruébalo en línea! Aunque es bastante largo para calcular jajaja.

C (gcc) , 35 31 bytes

f(x){return~x&1?f(x/2):!(x&2);}

Se cambió a una implementación recursiva. Pruébalo en línea!

Java 8, 17 bytes

n->(n&2*(n&-n))<1

Puerto sencillo de la respuesta Python 3 de LeakyNun . No estoy lo suficientemente familiarizado con las operaciones bit a bit y la precedencia del operador para ver una solución más corta; tal vez hay una manera de evitar la parentetesis extra?

Japt , 10 8 9 bytes

!+¢g¢a1 É

Pruébalo en línea!

Explicación

!+¢   g    a1 É
!+Us2 gUs2 a1 -1 # Implicit input (U) as number
!+               # Return the boolean NOT of
      g          #   the character at index
       Us2       #     the input converted to binary
           a1    #     the index of its last 1
              -1 #     minus 1
      g          #   in string
  Us2            #     the input converted to binary

JavaScript (ES6), 53 34 bytes

a=>eval("for(;~a&1;a/=2);~a>>1&1")

PHP> = 7.1, 32 bytes

<?=1^!trim(decbin($argn),0)[-2];

PHP Sandbox en línea

PHP , 40 bytes

for($i=$argn;$i%2<1;)$i/=2;echo$i/2%2^1;

Pruébalo en línea!

PHP , 41 bytes

<?=1^preg_match("#110*$#",decbin($argn));

Pruébalo en línea!

Lisp común, 56 bytes

(defun f(n)(if(oddp n)(- 1(mod #1=(ash n -1)2))(f #1#)))

Pruébalo en línea!

Chip , 93 bytes

HZABCDEFG,t
 ))))))))^~S
H\\\\\\\/v~a
G\\\\\\/v'
F\\\\\/v'
E\\\\/v'
D\\\/v'
C\\/v'
B\/v'
A/-'

Toma la entrada como pequeños bytes endian. (El TIO tiene un poco de python que hace esto por usted). Da salida como 0x0o0x1 . (El TIO usa xxd para inspeccionar el valor).

Pruébalo en línea!

¿Cómo se hace esto?

El chip mira la entrada de un byte a la vez, por lo que el manejo de la entrada multibyte agrega algo de volumen, pero no tanto como temía.

Vamos a entrar en eso:

HZABCDEFG

Estos son HZ, bit alto del byte anterior (si había uno), y A- G, los siete bits más bajos del byte actual. Estos se utilizan para localizar el bit de ajuste más bajo del número.

        ,t
))))))))^~S

Cuando se encuentra el bit de ajuste más bajo, tenemos algunas cosas que hacer. Este primer fragmento dice "si tenemos un bit establecido (el )'s), entonces deje de Spresionar la salida y termine después de imprimir la respuesta.

H\\\\\\\/v~a
G\\\\\\/v'
...
A/-'

Cualquier parte del byte actual (A - H) solo está precedido por un grupo de ceros y luego uno ( \y /: estos miran los bits directamente al norte de ellos; podemos confiar en que todos los bits anteriores eran cero) se pasan a los cables en la derecha ( v, ', ...), a continuación, el que sea valor se se invierte y se da como el bit bajo de salida ( ~a).