Tarea:

Dada una entrada entera, averigua si es o no un Número de Cyclops.

¿Qué es un número de Cyclops, puede preguntar? ¡Bueno, es un número cuya representación binaria solo tiene uno 0en el centro!

Casos de prueba:

Input | Output | Binary  | Explanation
--------------------------------------
0     | truthy | 0       | only one zero at "center"
1     | falsy  | 1       | contains no zeroes
5     | truthy | 101     | only one zero at center
9     | falsy  | 1001    | contains two zeroes (even though both are at the center)
10    | falsy  | 1010    | contains two zeroes
27    | truthy | 11011   | only one zero at center
85    | falsy  | 1010101 | contains three zeroes
101   | falsy  | 1100101 | contains three zeroes
111   | falsy  | 1101111 | only one zero, not at center
119   | truthy | 1110111 | only one zero at center

Entrada:

• Un entero o tipos equivalentes. ( int, long, decimal, Etc.)

• Suponga que si la evaluación de la entrada da como resultado un desbordamiento de enteros u otros problemas no deseados, entonces esa entrada no tiene que evaluarse.

Salida:

• Verdad o falsedad.

• La salida de verdad / falsedad debe cumplir con las especificaciones del lenguaje utilizado para verdad / falsedad. (p. ej., C es 0tan falso, distinto de cero como verdadero)

Reglas de desafío:

• Se supone que una entrada menor que 0 es falsa y, por lo tanto, no es necesario evaluarla.

• Si la longitud de la representación binaria del número es par, entonces el número no puede ser un número de Cyclops.

Reglas generales:

• Este es el código de golf , por lo que gana la respuesta más corta en bytes.

• Las lagunas predeterminadas están prohibidas.

• Se aplican reglas estándar para su respuesta con las reglas de E / S predeterminadas .

Este es mi primer desafío de programación de puzzles y golf de código , por lo que cualquier comentario sobre cómo debería mejorar sería muy apreciado.

Japt, 8 bytes

1¥¢q0 äè

Ejecútalo en línea

Explicación:

1¥¢q0 äè   
                                                              119
  ¢          // Convert the input into a binary string        "1110111"
   q0        // Split the string on "0"                       ["111","111"]
      ä      // Reduce each item by:                            a     b
       è     //   Seeing how many times a is found in b       [1]
 1¥          // == 1; See if the result equals 1              True                                         

La idea es dividir la cadena binaria en 0, lo que produciría dos elementos si solo hay uno 0. Luego vemos si el primer elemento coincide con el segundo para garantizar que sea palindrómico. Si la cadena binaria contiene múltiples 0s, entonces la reducción devolvería una matriz de elementos múltiples y eso fallaría la ==1condición. Si la cadena binaria contiene uno 0, pero no es palindrómico, äèregresará 0porque bcontiene 0coincidencias de a.

Python 2 , 30 bytes

lambda n:(2*n^2*n+3)**2==8*n+9

Pruébalo en línea!

Tenga en cuenta que 2*n^2*n+3es el bit xor de 2*ny 2*n+3, porque esa es la precedencia del operador de Python.

Código de máquina x86, 17 bytes

8D 47 01 31 F8 89 C2 F7 D2 0F AF C2 8D 44 78 02 C3

Los bytes anteriores definen una función que acepta un valor de entrada de entero de 32 bits (en el EDIregistro para este ejemplo, siguiendo una convención de llamada común del Sistema V, pero en realidad podría elegir prácticamente cualquier registro de entrada que desee sin afectar el tamaño del resultado resultante código) y devuelve un resultado (en el EAXregistro) que indica si el valor de entrada es un número de Cyclops.

Se supone que la entrada es un entero sin signo, ya que las reglas de desafío establecen que podemos ignorar los valores negativos.

La lógica de decisión se toma prestada de la respuesta de Neil : dado que un número de Cyclops tiene la forma , podemos usar una serie de operaciones de giro de bits para verificar el entrada.$n = (2 ^ k + 1) (2 ^ { k - 1 } - 1)$

Nota: El valor de retorno es verdadero / falso, pero la semántica se invierte, de modo que la función devolverá falso para un número de Cyclops. Afirmo que esto es legal porque el código de máquina no tiene "especificaciones para veracidad / falsedad", que es el requisito en la pregunta. (Vea a continuación una versión alternativa si cree que esto es trampa).

En mnemotecnia en lenguaje ensamblador, esto es:

; EDI = input value
; EAX = output value (0 == Cyclops number)
8D 47 01           lea    eax, [edi + 1]          ; \ EAX = ((EDI + 1) ^ EDI)
31 F8              xor    eax, edi                ; /
89 C2              mov    edx, eax                ; \ EDX = ~EAX
F7 D2              not    edx                     ; /
0F AF C2           imul   eax, edx                ; EAX *= EDX
8D 44 78 02        lea    eax, [eax + edi*2 + 2]  ; EAX  = (EAX + (EDI * 2) + 2)
C3                 ret                            ; return, with EAX == 0 for Cyclops number

Pruébalo en línea!

Según lo prometido, si cree que es una trampa invertir la semántica de verdad / falsedad incluso en el código de máquina donde no hay estándares o convenciones reales, agregue tres bytes más, para un total de 21 bytes :

; EDI = input value
; AL  = output value (1 == Cyclops number)
8D 47 01           lea    eax, [edi + 1]          ; \ EAX = ((EDI + 1) ^ EDI)
31 F8              xor    eax, edi                ; /
89 C2              mov    edx, eax                ; \ EDX = ~EAX
F7 D2              not    edx                     ; /
0F AF C2           imul   eax, edx                ; EAX *= EDX
8D 44 78 01        lea    eax, [eax + edi*2 + 1]  ; EAX  = (EAX + (EDI * 2) + 1)
40                 inc    eax                     ; EAX += 1
0F 94 C0           setz   al                      ; AL = ((EAX == 0) ? 1 : 0)
C3                 ret                            ; return, with AL == 1 for Cyclops number

La primera mitad de este código es la misma que la original (a través de las imulinstrucciones). El leaes casi lo mismo, pero en lugar de agregar una constante 2, solo agrega una constante 1. Esto se debe a que la siguiente incinstrucción incrementa el valor en el EAXregistro en 1 para establecer las banderas. Si se establece el indicador "cero", la setzinstrucción se establecerá ALen 1; de lo contrario, ALse establecerá en 0. Esta es la forma estándar en que un compilador de C generará código de máquina para devolver a bool.

Cambiar la constante agregada en la leainstrucción obviamente no cambia el tamaño del código, y la incinstrucción es muy pequeña (solo 1 byte), pero la setzinstrucción es de 3 bytes. Desafortunadamente, no puedo pensar en una forma más corta de escribirlo.

Regex (ECMAScript), 60 58 57 60 58 bytes

La entrada está en unario, como la longitud de una cadena de s.$n$x

ADVERTENCIA DE SPOILER : Para la raíz cuadrada, esta expresión regular utiliza una variante del algoritmo de multiplicación generalizado, que no es obvio y podría ser un rompecabezas gratificante para resolver por su cuenta. Para obtener más información, consulte una explicación de esta forma del algoritmo en Buscar un número Rocco .

-2 bytes al permitir el retroceso en la búsqueda de $z$
-1 byte gracias a Grimy , al buscar $z$ de menor a mayor en lugar de viceversa
+3 bytes para manejar cero
-2 bytes moviendo la captura de raíz cuadrada fuera de la búsqueda anticipada

$z$$n=2(n-z)+\sqrt{z}+1$$n$

^(x*)(?!(x(xx)+)\2*$)(x(x*))(?=(?=(\4*)\5+$)\4*$\6)x\1$|^$

Pruébalo en línea!

^                 # N = tail
(x*)              # tail = Z, with the smallest value that satisfies the following
                  # assertions (which is no different from the largest value that
                  # would satisfy them, since no more than one value can do so);
                  # \1 = N - Z

(?!(x(xx)+)\2*$)  # Assert Z is a power of 2

# Assert Z is a perfect square, and take its square root
(x(x*))           # \4 = square root of Z; \5 = \4 - 1; tail = N - \1 - \4
(?=(\4*)\5+$)     # iff \4*\4 == Z, then the first match here must result in \6==0
(?=\4*$\6)        # test for divisibility by \4 and for \6==0 simultaneously

# Assert that N == \1*2 + \4 + 1. If this fails, then due to a golf optimization,
# the regex engine will backtrack into the capturing of \4, and try all smaller
# values to see if they are the square root of Z; all of these smaller values will
# fail, because the \4*\4==Z multiplication test only matches for one unique value
# of \4.
x\1$

|^$               # Match N==0, because the above algorithm does not

JavaScript (Node.js) , 20 bytes

p=>~p==(p^=p+1)*~p/2

Pruébalo en línea!

Tal vez esto sea correcto, tal vez.

Gracias Grimy, 1 byte guardado.

JavaScript (Node.js) , 32 bytes

f=(p,q)=>p&1?f(p/2,q+q|2):!(p^q)

Pruébalo en línea!

JavaScript (Node.js) , 34 bytes

p=>/^(1*)0\1$/.test(p.toString(2))

Pruébalo en línea!

Perl 6 , 23 bytes

{.base(2)~~/^(1*)0$0$/}

Pruébalo en línea!

Solución basada en expresiones regulares

Japt , 25 19 10 9 bytes

¢êÅ©1¶¢èT

Gracias a @Shaggy por -1 byte

Pruébalo en línea!

Mathematica (lenguaje Wolfram), 32 31 bytes

¡1 byte guardado gracias a J42161217!

OddQ@Log2[#+Floor@Sqrt[#/2]+2]&

Pruébalo en línea!

Función pura que toma un entero como entrada y regresa Trueo False. Basándose en el hecho (divertido para probar!) Que un número nes Cyclops si y sólo si nmás la raíz cuadrada de n/2más 2rondas a una potencia impar de 2. (Se puede sustituir Floorpor cualquiera Ceilingo Roundtodo el tiempo que también se reemplaza +2por +1.) Retornos Truea la entrada 0.

Rubí , 24 bytes

->x{x+x+2==(1+x^=x+1)*x}

Pruébalo en línea!

Japt, 8 bytes

¢ðT ¥¢Êz

¡Gracias a Luis felipe de Jesus Munoz por arreglar mi presentación!

Pruébalo en línea!

Antigua solución basada en expresiones regulares, 15 bytes

¤f/^(1*)0\1$/ l

Devuelve 1 para verdadero, 0 para falso.

Pruébalo en línea!

Jalea ,  8  7 bytes

-1 gracias a Erik the Outgolfer (use isPalindrome incorporado, en ŒḂlugar de ⁼Ṛ$)

B¬ŒḂ⁼SƊ

Un enlace monádico que acepta un número entero que produce 1(verdad) o 0(falsey).

Pruébalo en línea!

¿Cómo?

B¬ŒḂ⁼SƊ - Link: integer             e.g. 1    9          13         119
B       - to base 2                      [1]  [1,0,0,1]  [1,1,0,1]  [1,1,1,0,1,1,1]
 ¬      - logical NOT (vectorises)       [0]  [0,1,1,0]  [0,0,1,0]  [0,0,0,1,0,0,0]
      Ɗ - last three links as a monad:
  ŒḂ    -   is a palindrome?             1    1          0          1
     S  -   sum                          0    2          1          1
    ⁼   -   equal?                       0    0          0          1

Haskell , 32 bytes

f n=or[2*4^k-2^k-1==n|k<-[0..n]]

Pruébalo en línea!

Regex (ECMAScript), 53 47 bytes

-6 bytes gracias a Deadcode y Grimy

^((?=(x*?)(\2((x+)x(?=\5$))+x$))(?!\2{6})\3x)*$

Pruébalo en línea!

Brachylog , 8 bytes

ḃD↔Dḍ×ᵐ≠

Este es un predicado que tiene éxito si su entrada es un número de Cyclops y falla si su entrada no es un número de Cyclops. El éxito / fracaso es el concepto de verdad / falsey más fundamental en Brachylog.

Pruébalo en línea! O bien, encuentre todas las salidas verdaderas hasta 10000 .

Explicación

          Input is an integer
ḃ         Get its binary representation, a list of 1's and 0's
 D        Call that list D
  ↔       When reversed...
   D      It's the same value D
    ḍ     Dichotomize: break the list into two halves
          One of these halves should be all 1's; the other should contain the 0
     ×ᵐ   Get the product of each half
       ≠  Verify that the two products are not equal

Esto tiene éxito solo cuando se le da un número de Cyclops, porque:

• Si la representación binaria no es un palíndromo, D↔Dfallará; En lo que sigue, podemos suponer que es un palíndromo.
• Si hay más de un cero, ambas mitades contendrán al menos un cero. Por lo tanto, los productos serán cero y ×ᵐ≠fallarán.
• Si no hay cero, ambas mitades contendrán solo unas. Entonces los productos serán uno y ×ᵐ≠fallarán.
• Eso deja el caso donde hay exactamente un cero; Como ya sabemos que tenemos un palíndromo, este debe ser el bit central. Aparecerá en una mitad, haciendo que el producto de esa mitad sea cero; la otra mitad contendrá todos, por lo que su producto será uno. Entonces tenemos 1 ≠ 0, ×ᵐ≠tiene éxito, y todo el predicado tiene éxito.

Ruby , 27 24 bytes

Convierte a binario y verifica con una expresión regular. Devuelve 0si es verdadero, nilsi es falso.

-3 bytes gracias a GB .

->n{"%b"%n=~/^(1*)0\1$/}

Pruébalo en línea!

Para dos bytes más, hay un puerto directo de la solución Python:

->n{(2*n^2*n+3)**2==8*n+9}

05AB1E , 8 (o 9) bytes

bD0¢sÂQ*

Pruébelo en línea o verifique todos los casos de prueba .

Devuelve 1si es verdad; 0o cualquier número entero positivo que no sea 1falsey. En 05AB1E solo 1es verdad y todo lo demás es falso, pero no estoy seguro de si esta es una salida permitida, o si la salida debería ser dos valores consistentes y únicos. Si es el segundo, Θse puede agregar un final para que todas las salidas que no 1sean 0:

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

b     # Convert the (implicit) input-integer to a binary-string
 D    # Duplicate it
  0¢  # Count the amount of 0s
 s    # Swap to get the binary again
  ÂQ  # Check if it's a palindrome
 *    # Multiply both (and output implicitly)

  Θ   # Optionally: check if this is truthy (==1),
      # resulting in truthy (1) or falsey (0)

Un enfoque aritmético sería de 10 bytes:

LoD<s·>*Iå

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

$a(n) = (2^n-1)*(2*2^n+1)$

L        # Create a list in the range [1, (implicit) input-integer]
 o       # For each integer in the list, take 2 to the power this integer
  D<     # Create a copy, and decrease each value by 1
  s·     # Get the copied list again, and double each value
    >    # Then increase each value by 1
  *      # Multiply the numbers at the same indices in both lists
     Iå  # Check if the input-integer is in this list
         # (and output the result implicitly)

Excel, 97 63 bytes

=A1=2*4^(ROUND(LOG(A1,4),0))-2^(ROUND(LOG(A1,4),0))-1

Calcula 2 números:

El doble de la potencia de 4 más cercana
>Num|Binary|2*Power4|Binary
> 1| 1| 2* 1= 2| 10
> 2| 10| 2* 4= 8| 1000
> 4| 100| 2* 4= 8| 1000
> 20| 10100| 2*16=32|100000

1 más la raíz cuadrada de la potencia de 4 más cercana
>Num|Binary|1+√Power4|Binary
> 1| 1|1+ √1= 2| 10
> 2| 10|1+ √4= 3| 11
> 4| 100|1+ √4= 3| 11
> 20| 10100|1+ √16= 5| 101

Luego reste el segundo número del primero:

>Num|Binary|2*Power4|Binary|1+√Power4|Binary|a-b|Binary
> 1| 1| 2* 1= 2| 10|1+ √1= 2| 10| 0| 0
> 2| 10| 2* 4= 8| 1000|1+ √4= 3| 11| 5| 101
> 4| 100| 2* 4= 8| 1000|1+ √4= 3| 11| 5| 101
> 20| 10100| 2*16=32|100000|1+ √16= 5| 101| 27| 11011

Y compara este resultado con el número original

Método antiguo

=DEC2BIN(A1)=REPLACE(REPT("1",1+2*INT(IFERROR(LOG(A1,2),0)/2)),1+IFERROR(LOG(A1,2),0)/2,1,"0")

Comience con el Log-base-2 de A1 y redondee hacia abajo el número par más cercano, luego agregue 1.

Luego, cree una cadena de esa cantidad de "1"s, y reemplace el carácter del medio con a "0"para crear un número de Cyclops con una longitud binaria que siempre es impar, y lo mismo o 1 menos que la longitud binaria de A1

Luego, compárelo con la representación binaria de A1

R , 37 33 bytes

(x=scan())%in%(2*4^(n=0:x)-2^n-1)

Pruébalo en línea!

R no tiene una función incorporada para convertir a binario, así que simplemente usé una de las fórmulas de OEIS para calcular una lista de términos de la secuencia.

n<-0:xgenera una generosa lista de valores iniciales. 2*4^(n<-0:x^2)-2^n-1)es la fórmula de OEIS, y luego comprueba si la entrada aparece en esa secuencia usando %in%.

-2 bytes al no tener que manejar entradas negativas. -2 bytes recordando que puedo cambiar <-a =.

C (gcc), 26 bytes

f(n){n=~n==(n^=-~n)*~n/2;}

Pruébalo en línea!

La respuesta del puerto de Neil . Se basa en la ordenación de operaciones definida por la implementación.

C ++ (clang), 38 bytes

int f(int n){return~n==(n^=-~n)*~n/2;}

Pruébalo en línea!

No se pueden omitir los tipos en C ++, no se puede omitir el retorno en clang, de lo contrario es idéntico.

C (gcc) ,  29 28  27 bytes

Guardado 1 byte gracias a @ceilingcat

Un puerto de la respuesta JS de 21 bytes por @tsh .

f(p){p=2*~p==~(p=-~p^p)*p;}

Pruébalo en línea!

J , 22 19 17 15 14 bytes

-3 bytes gracias a BolceBussiere!

-4 bytes gracias a ngn!

-1 byte gracias a Traws!

J , 14 bytes

1=1#.(*:|.)@#:

Pruébalo en línea!

Jalea , 9 bytes

BŒḂaB¬S=1

Pruébalo en línea!

Adjunto , 22 bytes

{Flip@_=_∧1=0~_}@Bin

Pruébalo en línea!

Alternativas

27 bytes: {BitXor[2*_,2*_+3]^2=8*_+9}

27 bytes: {BitXor@@(2*_+0'3)^2=8*_+9}

27 bytes: {Palindromic@_∧1=0~_}@Bin

28 bytes: {BitXor[...2*_+0'3]^2=8*_+9}

28 bytes: {BitXor[…2*_+0'3]^2=8*_+9}

28 bytes: {Same@@Bisect@_∧1=0~_}@Bin

29 bytes: {_[#_/2|Floor]=0∧1=0~_}@Bin

30 bytes: Same@Bin@{_+2^Floor[Log2@_/2]}

30 bytes: {_[#_/2|Floor]=0and 1=0~_}@Bin

Retina 0.8.2 , 38 37 bytes

.+
$*
+`^(1+)\1
$+0
10
1
^((1+)0\2)?$

Pruébalo en línea! El enlace incluye casos de prueba. Editar: después de la aclaración, la solución anterior no manejaba el cero correctamente. Explicación:

.+
$*

Convierte de decimal a unario.

+`^(1+)\1
$+0
10
1

Convierta de unario a binario, utilizando el método de la wiki de Retina.

^((1+)0\2)?$

Verifique el mismo número de 1s antes y después de 0, o una cadena vacía (que es como la conversión anterior maneja cero).

Lote, 39 37 bytes

@cmd/cset/a"m=%1^-~%1,!(m/2*(m+2)-%1)

$n = (2 ^ k + 1) (2 ^ { k - 1 } - 1)$$m = 2 ^ k - 1$$n = \lfloor \frac m 2 \rfloor ( m + 2 )$$n$

Excel, 101107 bytes

-6 bytes gracias a @Chronocidal.

=AND(ISEVEN(LOG(A1,2)),MID(DEC2BIN(A1),LEN(DEC2BIN(A1))/2+1,1)="0",LEN(SUBSTITUTE(DEC2BIN(A1),1,))=1)

Realiza 3 verificaciones:

• Longitud impar

ISEVEN(LOG(A1,2))

• El personaje del medio es 0

MID(DEC2BIN(A1),LEN(DEC2BIN(A1))/2+1,1)="0"

• Hay un solo 0

LEN(SUBSTITUTE(DEC2BIN(A1),1,))=1

Regex (ECMAScript), 65 59 57 58 bytes

+1 byte para manejar 0 correctamente

^((((x*)xx)\3)x)?(?=(\1*)\2*(?=\4$)((x*)(?=\7$)x)*$)\1*$\5

Pruébalo en línea!

$(2^k - 1) (2^{k+1} + 1)$

VBA, 41 36 bytes

x=2^Int([Log(A1,4)]):?[A1]=2*x^2-x-1

Ejecutar en la ventana Inmediato, con la Declaración explícita desactivada. La entrada es la celda A1de la hoja activa. Salidas Verdadero / Falso a la ventana inmediata.

Utiliza la misma lógica que mi respuesta de Excel para encontrar el número de Cyclops del mismo número de bits (¡o 1 bit más corto si hay un número par!) Y luego lo compara con la entrada.

Guarda algunos bytes al calcular los números de Cyclops reduciéndolos a la forma y = 2x^2 - x - 1(donde x = n-1para el enésimo número de Cyclops, o x = 2^Int(Log([A1])/Log(4))para encontrar el número de Cyclops más grande con un número menor o igual de bits) y almacenando x en una variable

(-5 Bytes gracias a Taylor Scott !)

PHP , 74 bytes

function($x){return($c=strlen($a=decbin($x)))&1&&trim($a,1)===$a[$c/2|0];}

Pruébalo en línea!

Enfoque no matemático totalmente ingenuo, solo cadenas.

function cyclops( $x ) {
    $b = decbin( $x );     // convert to binary string (non-zero left padded)
    $l = strlen( $b );     // length of binary string
    $t = trim( $b, 1 );    // remove all 1's on either side
    $m = $b[ $l / 2 |0 ];  // get the middle "bit" of the binary string
    return 
        $l & 1 &&          // is binary string an odd length?
        $t === $m;         // is the middle char of the binary string the same as
                           // the string with left and right 1's removed? (can only be '0')
}

O 60 bytes basados ​​en el algoritmo de @ Chronocidal anterior .

function($x){return decbin($x)==str_pad(0,log($x,2)|1,1,2);}

Pruébalo en línea!

Haskell, 82 bytes

import Text.Printf
(`all`[(==)<*>reverse,("0"==).filter(<'1')]).flip($).printf"%b"

Y un puerto de la solución Python de xnor:

Haskell, 47 bytes

import Data.Bits
\n->(2*n`xor`(2*n+3))^2==8*n+9