Tarefa:

Dada uma entrada inteira, descubra se é ou não um número Cyclops.

O que é um número do Ciclope, você pode perguntar? Bem, é um número cuja representação binária tem apenas um 0no centro!

Casos de teste:

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:

• Um número inteiro ou tipos equivalentes. ( int, long, decimal, Etc.)

• Suponha que se a avaliação da entrada resultar em um estouro de número inteiro ou em outros problemas indesejáveis, essa entrada não precisará ser avaliada.

Resultado:

• Verdade ou falsidade.

• A saída verdade / falsidade deve atender às especificações do idioma usado para verdade / falsidade. (por exemplo, C tem 0como falso, diferente de zero como verdadeiro)

Regras do Desafio:

• A entrada menor que 0 é considerada falsa e, portanto, não precisa ser avaliada.

• Se o comprimento da representação binária do número for par, o número não poderá ser um número do Ciclope.

Regras gerais:

• Isso é código-golfe , então as respostas mais curtas em bytes vencem !.

• As brechas padrão são proibidas.

• Regras padrão se aplicam à sua resposta com regras de E / S padrão .

Este é o meu primeiro desafio de quebra-cabeças de programação e código de golfe , portanto qualquer feedback sobre como devo melhorar seria muito apreciado!

Japonês, 8 bytes

1¥¢q0 äè

Execute on-line

Explicação:

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                                         

A idéia é dividir a string binária em 0, o que produziria dois itens se houver apenas um 0. Então, vemos se o primeiro item corresponde ao segundo para garantir que seja palindrômico. Se a cadeia binária contiver vários 0s, a redução retornará uma matriz de vários itens e isso falhará na ==1condição. Se a cadeia binária contiver uma 0, mas não for palindrômica, äèretornará 0porque bcontém 0correspondências de a.

Python 2 , 30 bytes

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

Experimente online!

Observe que 2*n^2*n+3é o xor bit a bit de 2*ne 2*n+3, porque essa é a precedência do operador do Python.

Código da máquina x86, 17 bytes

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

Os bytes acima definem uma função que aceita um valor de entrada inteiro de 32 bits (no EDIregistro para este exemplo, seguindo uma convenção de chamada comum do System V, mas você pode escolher praticamente qualquer registro de entrada que desejar, sem afetar o tamanho do resultado código) e retorna um resultado (no EAXregistro) indicando se o valor de entrada é um número do Ciclope.

A entrada é assumida como um número inteiro não assinado, pois as regras de desafio determinam que podemos ignorar valores negativos.

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

Nota: O valor de retorno é verdadeiro / falso, mas a semântica é invertida, de modo que a função retornará falso para um número do Ciclope. Eu afirmo que isso é legal porque o código da máquina não tem "especificações de verdade / falsidade", que é o requisito da pergunta. (Veja abaixo uma versão alternativa, se você acha que isso é trapaça.)

Nos mnemônicos da linguagem assembly, é o seguinte:

; 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

Experimente online!

Como prometido, se você acha que é trapaça inverter a semântica da verdade / falsidade, mesmo em código de máquina onde não há padrões ou convenções reais, adicione mais três bytes, num 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

A primeira metade deste código é igual ao original (abaixo através da imulinstrução). O leaé quase o mesmo, mas, em vez de adicionar uma constante 2, apenas adiciona uma constante 1. Isso ocorre porque a incinstrução a seguir aumenta o valor no EAXregistro em 1 para definir os sinalizadores. Se o sinalizador "zero" estiver definido, a setzinstrução será definida ALpara 1; caso contrário, ALserá definido como 0. Essa é a maneira padrão em que um compilador C irá gerar código de máquina para retornar a bool.

Alterar a constante adicionada na leainstrução obviamente não altera o tamanho do código, e a incinstrução é muito pequena (apenas 1 byte), mas a setzinstrução tem 3 bytes bastante impressionantes. Infelizmente, não consigo pensar em nenhuma maneira mais curta de escrevê-lo.

Regex (ECMAScript), 60 58 57 60 58 bytes

$n$x

AVISO DE SPOILER : Para a raiz quadrada, esse regex usa uma variante do algoritmo de multiplicação generalizada, o que não é óbvio e pode ser um quebra-cabeça gratificante para você resolver sozinho. Para obter mais informações, consulte uma explicação para esta forma do algoritmo em Localizar um número Rocco .

$z$
$z$

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

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

Experimente online!

^                 # 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

Experimente online!

Talvez isso esteja correto, talvez.

Obrigado Grimy, 1 byte salvo.

JavaScript (Node.js) , 32 bytes

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

Experimente online!

JavaScript (Node.js) , 34 bytes

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

Experimente online!

Perl 6 , 23 bytes

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

Experimente online!

Solução baseada em Regex

Japonês , 25 19 10 9 bytes

¢êÅ©1¶¢èT

Obrigado a @Shaggy por -1 byte

Experimente online!

Mathematica (língua Wolfram), 32 31 bytes

1 byte economizado graças a J42161217!

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

Experimente online!

Função pura, recebendo um número inteiro como entrada e retornando Trueou False. Com base no fato (divertido de provar!) Que um número né Ciclope se, e somente se, nmais a raiz quadrada de n/2mais 2arredondar para uma potência ímpar de 2. (Pode-se substituir Floorpor um Ceilingou Roundcontanto que também substitua +2por +1.) Retorna Truena entrada 0.

Ruby , 24 bytes

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

Experimente online!

Japonês, 8 bytes

¢ðT ¥¢Êz

Agradeço a Luis felipe de Jesus Munoz por corrigir minha submissão!

Experimente Online!

Solução antiga baseada em regex, 15 bytes

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

Retorna 1 para verdadeiro, 0 para falso.

Experimente Online!

Geléia ,  8  7 bytes

-1 graças a Erik the Outgolfer (use o isPalindrome embutido, em ŒḂvez de ⁼Ṛ$)

B¬ŒḂ⁼SƊ

Um link monádico que aceita um número inteiro que produz 1(verdade) ou 0(falsey).

Experimente online!

Quão?

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]]

Experimente online!

Regex (ECMAScript), 53 47 bytes

-6 bytes graças a Deadcode e Grimy

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

Experimente online!

Braquilog , 8 bytes

ḃD↔Dḍ×ᵐ≠

Este é um predicado que terá êxito se sua entrada for um número do Ciclope e falhará se sua entrada não for um número do Ciclope. Sucesso / fracasso é o conceito mais fundamental de verdade / falsey em Brachylog.

Experimente online! Ou encontre todas as saídas verdadeiras até 10000 .

Explicação

          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

Isso é bem-sucedido somente quando recebe um número do Ciclope, porque:

• Se a representação binária não for um palíndromo, D↔Dfalhará; no que se segue, podemos assumir que é um palíndromo.
• Se houver mais de um zero, as duas metades conterão pelo menos um zero. Portanto, os produtos serão zero e ×ᵐ≠falharão.
• Se não houver zero, as duas metades conterão apenas uma. Portanto, os produtos serão um e ×ᵐ≠falharão.
• Isso deixa o caso em que há exatamente um zero; Como já sabemos que temos um palíndromo, esse deve ser o ponto central. Ele aparecerá na metade, fazendo com que o produto da metade seja zero; a outra metade conterá todos, portanto, seu produto será um. Então temos 1 ≠ 0, ×ᵐ≠obtém sucesso e todo o predicado é bem-sucedido.

Ruby , 27 24 bytes

Converta em binário e verifique com uma regex. Retorna 0se verdadeiro, nilse falso.

-3 bytes graças a GB .

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

Experimente online!

Por mais dois bytes, há uma porta direta da solução Python:

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

05AB1E , 8 (ou 9) bytes

bD0¢sÂQ*

Experimente online ou verifique todos os casos de teste .

Retorna 1se realmente; 0ou qualquer número inteiro positivo que não 1seja falsey. Em 05AB1E, apenas 1é verdade e todo o resto é falsey, mas não tenho certeza se essa é uma saída permitida ou se a saída deve ser dois valores consistentes e únicos. Se o segundo, um final Θpode ser adicionado para que todas as saídas que não 1sejam 0:

Experimente online ou verifique todos os casos de teste .

Explicação:

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)

Uma abordagem aritmética seria 10 bytes:

LoD<s·>*Iå

Experimente online ou verifique todos os casos de teste .

Explicação:

$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:

Duas vezes a potência mais próxima de 4
>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 Mais a raiz quadrada da potência mais próxima de 4
>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

Subtraia o segundo número do primeiro:

>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

E compare este resultado com o número original

Método antigo

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

Comece com o Log-base-2 de A1 e arredonde-o para o número par mais próximo e adicione 1.

Em seguida, crie uma sequência de muitos "1"s e substitua o caractere do meio por a "0"para criar um número do Ciclope com um comprimento binário sempre ímpar e igual ou 1 a menos que o comprimento binário de A1

Em seguida, compare-o com a representação binária de A1

R , 37 33 bytes

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

Experimente online!

R não tem um built-in para converter em binário, então eu simplesmente usei uma das fórmulas do OEIS para calcular uma lista de termos da sequência.

n<-0:xgera uma lista generosa de valores iniciais. 2*4^(n<-0:x^2)-2^n-1)é a fórmula do OEIS e, em seguida, verifica se a entrada aparece nessa sequência usando %in%.

-2 bytes por não precisar lidar com entradas negativas. -2 bytes lembrando que posso mudar <-para =.

C (gcc), 26 bytes

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

Experimente online!

Resposta do porto de Neil . Baseia-se na ordem de operações definida pela implementação.

C ++ (clang), 38 bytes

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

Experimente online!

Não é possível omitir os tipos em C ++, não pode omitir o retorno em clang, caso contrário, idêntico.

C (gcc) ,  29 28  27 bytes

Guardado 1 byte graças a @ceilingcat

Uma porta do JS de 21 bytes responde por @tsh .

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

Experimente online!

J , 22 19 17 15 14 bytes

-3 bytes graças ao BolceBussiere!

-4 bytes graças a ngn!

-1 byte graças ao Traws!

J , 14 bytes

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

Experimente online!

Geléia , 9 bytes

BŒḂaB¬S=1

Experimente online!

Anexo , 22 bytes

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

Experimente online!

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)?$

Experimente online! O link inclui casos de teste. Edit: Após esclarecimentos, a solução anterior não tratava zero corretamente. Explicação:

.+
$*

Converta de decimal para unário.

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

Converter de unário em binário, usando o método do wiki Retina.

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

Verifique o mesmo número de 1s antes e depois da 0ou uma sequência vazia (que é como a conversão acima lida com zero).

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, 101 107 bytes

-6 bytes graças a @Chronocidal.

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

Executa 3 verificações:

• Comprimento ímpar

ISEVEN(LOG(A1,2))

• O caractere do meio é 0

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

• Existe um único 0

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

Regex (ECMAScript), 65 59 57 58 bytes

+1 byte para manipular 0 corretamente

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

Experimente online!

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

VBA, 41 36 bytes

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

Execute na janela Imediata, com a Declaração Explícita desativada. A entrada é a célula A1da planilha ativa. Emite Verdadeiro / Falso na janela imediata.

Usa a mesma lógica da minha Resposta do Excel para encontrar o número do Ciclope com o mesmo número de bits (ou 1 bit menor se houver um número par!) E depois compara isso com a entrada.

Economiza alguns bytes ao calcular os números do Ciclope, reduzindo-os para o formato y = 2x^2 - x - 1(onde é x = n-1o enésimo número do Ciclope ou x = 2^Int(Log([A1])/Log(4))para encontrar o maior número de Ciclopes com um número menor ou igual de bits) e armazenando x em uma variável

(-5 bytes graças a Taylor Scott !)

PHP , 74 bytes

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

Experimente online!

Abordagem não matemática totalmente ingênua, apenas seqüências de caracteres.

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')
}

Ou 60 bytes com base no algoritmo de @ Chronocidal acima .

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

Experimente online!

Haskell, 82 bytes

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

E uma porta da solução Python da xnor:

Haskell, 47 bytes

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