Aufgabe:

Finden Sie bei einer Ganzzahleingabe heraus, ob es sich um eine Zyklopenzahl handelt oder nicht.

Was ist eine Cyclops-Nummer? Nun, es ist eine Zahl, deren Binärdarstellung nur eine 0in der Mitte hat!

Testfälle:

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

Eingang:

• Eine Ganzzahl oder ein äquivalenter Typ. ( int, long, decimal, Etc.)

• Angenommen, wenn die Auswertung der Eingabe zu einem Ganzzahlüberlauf oder anderen unerwünschten Problemen führt, muss diese Eingabe nicht ausgewertet werden.

Ausgabe:

• Wahrheit oder Falschheit.

• Die Ausgabe von Wahrheiten / Falschheiten muss den Spezifikationen der verwendeten Sprache für Wahrheiten / Falschheiten entsprechen. (zB C hat 0so falsch, ungleich Null wie wahr)

Herausforderungsregeln:

• Eingaben, die kleiner als 0 sind, werden als falsch angenommen und müssen daher nicht ausgewertet werden.

• Wenn die Länge der binären Darstellung der Zahl gerade ist, kann die Zahl keine Cyclops-Zahl sein.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes !.

• Standardlücken sind verboten.

• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln .

Dies ist meine erste Programmier-Rätsel & Code-Golf- Herausforderung, daher wäre jedes Feedback zu meiner Verbesserung sehr dankbar!

Japt, 8 Bytes

1¥¢q0 äè

Führen Sie es online aus

Erläuterung:

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                                         

Die Idee ist, die Binärzeichenfolge bei zu teilen 0, was zwei Elemente ergeben würde, wenn es nur ein Element gibt 0. Dann prüfen wir, ob das erste Element mit dem zweiten übereinstimmt, um sicherzustellen, dass es palindrom ist. Wenn die Binärzeichenfolge mehrere 0s enthält , gibt die Reduzierung ein Array mit mehreren Elementen zurück, und dies würde die ==1Bedingung nicht erfüllen. Wenn die Binärzeichenfolge eine enthält 0, aber nicht palindromisch ist, äèwird zurückgegeben, 0weil sie Übereinstimmungen mit benthält .0a

Python 2 , 30 Bytes

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

Probieren Sie es online!

Beachten Sie, dass dies 2*n^2*n+3das bitweise xor von 2*nund ist 2*n+3, da dies die Operator-Priorität von Python ist.

x86-Maschinencode, 17 Byte

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

Die obigen Bytes definieren eine Funktion, die einen 32-Bit-Integer-Eingabewert akzeptiert (im EDIRegister für dieses Beispiel nach einer üblichen System V-Aufrufkonvention), aber Sie können praktisch jedes gewünschte Eingaberegister auswählen, ohne die Größe des Ergebnisses zu beeinflussen Code) und gibt ein Ergebnis (im EAXRegister) zurück, das angibt, ob der Eingabewert eine Cyclops-Nummer ist.

Die Eingabe wird als vorzeichenlose Ganzzahl angenommen, da nach den Challenge-Regeln negative Werte ignoriert werden können.

Die Entscheidungslogik ist Neils Antwort entlehnt : Da eine Cyclops-Zahl die Form , können wir eine Reihe von Bit-Twiddling-Operationen verwenden, um die zu überprüfen Eingang.$n = (2 ^ k + 1) (2 ^ { k - 1 } - 1)$

Hinweis: Der Rückgabewert ist wahr / falsch, aber die Semantik ist umgekehrt, so dass die Funktion für eine Cyclops-Nummer falsch zurückgibt. Ich behaupte, dass dies legal ist, da der Maschinencode keine "Spezifikationen für Wahrhaftigkeit / Falschheit" enthält, was die Anforderung in der Frage ist. (Eine alternative Version finden Sie weiter unten.)

In Assembler-Mnemonik ist dies:

; 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

Probieren Sie es online!

Wie versprochen, sollten Sie drei weitere Bytes hinzufügen, wenn Sie der Meinung sind, dass es Betrug ist, die Semantik von Wahrhaftigkeit / Falschheit auch in Maschinencode zu invertieren, für insgesamt 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

Die erste Hälfte dieses Codes ist die gleiche wie das Original (weiter unten in der imulAnweisung). Das leaist fast dasselbe, aber anstatt eine Konstante 2 hinzuzufügen, wird nur eine Konstante 1 hinzugefügt. Dies liegt daran, dass der folgende incBefehl den Wert im EAXRegister um 1 erhöht , um die Flags zu setzen. Wenn das "Null" -Flag gesetzt ist, wird der setzBefehl ALauf 1 gesetzt; Andernfalls ALwird auf 0 gesetzt. Dies ist die Standardmethode, mit der ein C-Compiler Maschinencode generiert, um a zurückzugeben bool.

Das Ändern der in der leaAnweisung hinzugefügten Konstante ändert offensichtlich nicht die Codegröße, und die incAnweisung ist sehr klein (nur 1 Byte), aber die setzAnweisung ist ziemlich satte 3 Bytes. Leider fällt mir keine kürzere Schreibweise ein.

Regex (ECMAScript), 60 58 57 60 58 Bytes

Die Eingabe ist als Länge einer Zeichenfolge von s unär.$n$x

SPOILER-WARNUNG : Für die Quadratwurzel verwendet dieser Regex eine Variante des verallgemeinerten Multiplikationsalgorithmus. Dies ist nicht offensichtlich und kann ein lohnendes Rätsel sein, das Sie selbst lösen können . Weitere Informationen finden Sie in der Erklärung zu dieser Form des Algorithmus unter Suchen einer Rocco-Nummer .

-2 Bytes durch Ermöglichen des Zurückverfolgens bei der Suche nach$z$ -1 Bytes dank Grimy , durch Suchen nach vom kleinsten zum größten anstatt umgekehrt +3 Bytes, um null -2 Bytes zu verarbeiten, indem die Quadratwurzel-Erfassung außerhalb des Lookaheads verschoben wirdz
$z$

Dies funktioniert durch Finden von , einer perfekten quadratischen Potenz von 2, für die . Nur die größte perfekte quadratische Potenz von 2, die nicht überschreitet, kann dies erfüllen. Aufgrund einer Golfoptimierung versucht der Regex jedoch, alle mit der kleinsten zu beginnen. Da jede einer Zyklopennummer entspricht, kann nur die größte zu einer Übereinstimmung führen.$z$$n=2(n-z)+\sqrt{z}+1$$n$

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

Probieren Sie es 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 Byte

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

Probieren Sie es online!

Vielleicht ist das richtig, vielleicht.

Danke Grimy, 1 Byte gespeichert.

JavaScript (Node.js) , 32 Byte

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

Probieren Sie es online!

JavaScript (Node.js) , 34 Byte

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

Probieren Sie es online!

Perl 6 , 23 Bytes

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

Probieren Sie es online!

Regex-basierte Lösung

Japt , 25 19 10 9 Bytes

¢êÅ©1¶¢èT

Vielen Dank an @Shaggy für -1 Byte

Probieren Sie es online!

Mathematica (Wolfram-Sprache), 32-31 Bytes

1 Byte gespart dank J42161217!

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

Probieren Sie es online!

Reine Funktion, die eine ganze Zahl als Eingabe nimmt und Trueoder zurückgibt False. Aufgrund der Tatsache , (Spaß zu beweisen!) , Dass eine Reihe nCyclops ist , wenn und nur wenn nplus der Quadratwurzel n/2und 2Runden bis auf eine ungerade Potenz von 2 (Ein ersetzen kann Floorentweder durch Ceilingoder Roundsolange man ersetzt auch +2durch +1.) Gibt Truebei der Eingabe zurück 0.

Ruby , 24 Bytes

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

Probieren Sie es online!

Japt, 8 Bytes

¢ðT ¥¢Êz

Vielen Dank an Luis felipe de Jesus Munoz für die Korrektur meiner Einsendung!

Probieren Sie es online!

Alte, auf Regex basierende Lösung, 15 Byte

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

Gibt 1 für wahr, 0 für falsch zurück.

Probieren Sie es online!

Gelee ,  8  7 Bytes

-1 danke an Erik the Outgolfer (benutze isPalindrome ŒḂ, anstatt ⁼Ṛ$)

B¬ŒḂ⁼SƊ

Ein monadischer Link, der eine ganze Zahl akzeptiert, die 1(wahr) oder 0(falsch) ergibt.

Probieren Sie es online!

Wie?

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

Probieren Sie es online!

Regex (ECMAScript), 53 47 Bytes

-6 Bytes dank Deadcode und Grimy

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

Probieren Sie es online!

Brachylog , 8 Bytes

ḃD↔Dḍ×ᵐ≠

Dies ist ein Prädikat, das erfolgreich ist, wenn seine Eingabe eine Cyclops-Nummer ist, und fehlschlägt, wenn seine Eingabe keine Cyclops-Nummer ist. Erfolg / Misserfolg ist das grundlegendste Konzept für Wahrhaftigkeit / Falschheit in Brachylog.

Probieren Sie es online! Oder finden Sie alle wahren Ausgaben bis zu 10000 .

Erläuterung

          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

Dies gelingt nur mit einer Cyclops-Nummer, weil:

• Wenn die Binärdarstellung kein Palindrom ist, D↔Dschlägt dies fehl. im Folgenden können wir davon ausgehen, dass es sich um ein Palindrom handelt.
• Wenn es mehr als eine Null gibt, enthalten beide Hälften mindestens eine Null. Die Produkte sind also beide Null und fallen ×ᵐ≠aus.
• Wenn es keine Null gibt, enthalten beide Hälften nur Einsen. Die Produkte werden also beide eins sein und ×ᵐ≠scheitern.
• Das lässt den Fall, in dem es genau eine Null gibt; Da wir bereits wissen, dass wir ein Palindrom haben, muss dies das zentrale Element sein. Es wird in einer Hälfte erscheinen, was dazu führt, dass das Produkt dieser Hälfte Null ist; Die andere Hälfte wird alle enthalten, also wird das Produkt eins sein. Dann haben wir 1 ≠ 0, ist ×ᵐ≠erfolgreich, und das ganze Prädikat ist erfolgreich.

Ruby , 27 24 Bytes

In Binär konvertieren und mit einem regulären Ausdruck prüfen. Gibt zurück, 0wenn wahr, nilwenn falsch.

-3 Bytes dank GB .

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

Probieren Sie es online!

Für zwei Bytes mehr gibt es einen direkten Port der Python-Lösung:

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

05AB1E , 8 (oder 9) Bytes

bD0¢sÂQ*

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Gibt zurück, 1wenn es wahr ist; 0oder irgendeine andere positive ganze Zahl 1als Falsey. In 05AB1E ist nur 1wahr und alles andere ist falsch, aber ich bin nicht sicher, ob dies eine zulässige Ausgabe ist oder ob die Ausgabe zwei konsistente und eindeutige Werte haben sollte. Wenn die zweiten, ein hinteres Θkann hinzugefügt werden , so dass alle Ausgänge außer 1werden 0:

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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)

Ein arithmetischer Ansatz wäre 10 Bytes:

LoD<s·>*Iå

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

$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

Berechnet 2 Zahlen:

Zweimal die nächste Potenz von 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 Plus die Quadratwurzel der nächsten Potenz von 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

Dann subtrahiere die zweite Zahl von der ersten:

>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

Und vergleichen Sie dieses Ergebnis mit der ursprünglichen Nummer

Alte Methode

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

Beginnen Sie mit der Log-Basis 2 von A1 und runden Sie sie auf die nächste gerade Zahl ab, dann addieren Sie 1.

Erstellen Sie als Nächstes eine Zeichenfolge mit so vielen "1"s und ersetzen Sie das mittlere Zeichen durch a "0", um eine Cyclops-Zahl mit einer Binärlänge zu erstellen, die immer ungerade ist und mindestens 1 der Binärlänge von A1 entspricht

Vergleichen Sie es dann mit der Binärdarstellung von A1

R , 37 33 Bytes

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

Probieren Sie es online!

R verfügt nicht über eine integrierte Funktion zum Konvertieren in Binärdateien, daher habe ich einfach eine der Formeln von OEIS verwendet, um eine Liste von Begriffen aus der Sequenz zu berechnen.

n<-0:xgeneriert eine großzügige Liste von Startwerten. 2*4^(n<-0:x^2)-2^n-1)ist die Formel von OEIS und prüft dann mit %in%.

-2 Bytes, da keine negativen Eingaben verarbeitet werden müssen. -2 Bytes durch die Erinnerung an die ich ändern kann <-zu =.

C (gcc), 26 Bytes

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

Probieren Sie es online!

Port of Neils Antwort . Verlässt sich auf die implementierungsdefinierte Reihenfolge der Vorgänge.

C ++ (clang), 38 Bytes

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

Probieren Sie es online!

Kann die Typen in C ++ nicht auslassen, kann die Rückgabe in clang nicht auslassen, sonst identisch.

C (GCC) ,  29 28  27 Bytes

1 Byte dank @ceilingcat gespeichert

Ein Port der 21-Byte-JS-Antwort von @tsh .

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

Probieren Sie es online!

J , 22, 19, 17, 15, 14 Bytes

-3 Bytes dank BolceBussiere!

-4 Bytes dank ngn!

-1 Byte dank Traws!

J , 14 Bytes

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

Probieren Sie es online!

Gelee , 9 Bytes

BŒḂaB¬S=1

Probieren Sie es online!

Attache , 22 Bytes

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

Probieren Sie es online!

Alternativen

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

Probieren Sie es online! Link enthält Testfälle. Bearbeiten: Nach der Klärung hat die vorherige Lösung die Null nicht richtig gehandhabt. Erläuterung:

.+
$*

Konvertiert von dezimal zu unär.

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

Konvertieren Sie von unär nach binär mit der Methode aus dem Retina-Wiki.

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

Überprüfen Sie, 1ob vor und nach 0oder nach einer leeren Zeichenfolge die gleiche Anzahl von s vorhanden ist (so behandelt die obige Konvertierung Null).

Batch, 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 dank @Chronocidal.

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

Führt 3 Überprüfungen durch:

• Ungerade Länge

ISEVEN(LOG(A1,2))

• Mittlerer Charakter ist 0

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

• Es gibt eine Single 0

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

Regex (ECMAScript), 65 59 57 58 Bytes

+1 Byte, um 0 richtig zu behandeln

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

Probieren Sie es online!

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

VBA, 41 36 Bytes

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

Im Direktfenster mit deaktivierter expliziter Deklaration ausführen. Die Eingabe ist die Zelle A1des aktiven Arbeitsblatts. Gibt True / False im unmittelbaren Fenster aus.

Verwendet die gleiche Logik wie meine Excel-Antwort , um die Cyclops-Nummer mit der gleichen Anzahl von Bits zu finden (oder 1 Bit kürzer, wenn es eine gerade Zahl gibt!) Und vergleicht diese dann mit der Eingabe.

Speichert einige Bytes bei der Berechnung von Cyclops-Zahlen, indem sie auf die Form reduziert werden y = 2x^2 - x - 1(wobei x = n-1für die n-te Cyclops-Nummer oder x = 2^Int(Log([A1])/Log(4))um die größte Cyclops-Nummer mit einer geringeren oder gleichen Anzahl von Bits zu finden) und x in einer Variablen gespeichert wird

(-5 Bytes dank Taylor Scott !)

PHP , 74 Bytes

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

Probieren Sie es online!

Völlig naiver, nicht mathematischer Ansatz, nur Streicher.

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

Oder 60 Bytes basierend auf dem obigen @ Chronocidal-Algorithmus .

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

Probieren Sie es online!

Haskell, 82 Bytes

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

Und eine Portierung der Python-Lösung von xnor:

Haskell, 47 Bytes

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