Vyxal 3, 9 bytes

B¨¬:/⇄$∑=

Vyxal It Online!

B¨¬:/⇄$∑=­⁡​‎‎⁡⁠⁢⁤‏‏​⁡⁠⁡‌⁢​‎⁠‎⁡⁠⁢‏⁠‎⁡⁠⁣‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁡‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁤‏⁠‎⁡⁠⁢⁣‏⁠‎⁡⁠⁣⁡‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏‏​⁡⁠⁡‌­
       ∑   # ‎⁡is the sum...
 ¨¬        # ‎⁢of flipped...
B          # ‎⁣bits...
   :  $ =  # ‎⁤equal to...
    /⇄     # ‎⁢⁡the truth-value of is it also a palindrome?
💎

Created with the help of Luminespire.

<script type="vyxal3">
B¨¬:/⇄$∑=
</script>
<script>
    args=[["0"],["1"],["5"],["9"],["10"],["27"],["85"],["101"],["111"],["119"]]
</script>
<script src="https://themoonisacheese.github.io/snippeterpreter/snippet.js" type="module"/>

APL(NARS), 48 chars

{∼2∣k←1+⌊2⍟1⌈⍵:0⋄((,0)≡m∼1)∧0=(2÷⍨k+1)⊃m←⍵⊤⍨k⍴2}

Input one number output 0 for false 1 for true. 1+⌊2⍟1⌈⍵ it seems return the number of binary digits of ⍵ if k is even return false else if k is odd the zero will be in the index (k+1)/2.

test:

  v←{∼2∣k←1+⌊2⍟1⌈⍵:0⋄((,0)≡m∼1)∧0=(2÷⍨k+1)⊃m←⍵⊤⍨k⍴2}  
  v¨0,⍳16
1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 

Dyalog APL, 39 bytes

{{(0=⍵[⌈2÷⍨≢⍵])∧1=+/0=⍵}⍵⊤⍨2⍴⍨1⌈⌈2⍟⍵+1}­⁡​‎‎⁡⁠⁣⁡⁡‏⁠‎⁡⁠⁣⁡⁢‏⁠‎⁡⁠⁣⁡⁣‏⁠‎⁡⁠⁣⁡⁤‏⁠‎⁡⁠⁣⁢⁡‏⁠‎⁡⁠⁣⁢⁢‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁢⁤⁣‏⁠‎⁡⁠⁢⁤⁤‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁢⁣⁤‏⁠‎⁡⁠⁢⁤⁡‏⁠‎⁡⁠⁢⁤⁢‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁢⁣⁡‏⁠‎⁡⁠⁢⁣⁢‏⁠‎⁡⁠⁢⁣⁣‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁢‏⁠‎⁡⁠⁢⁢⁤‏‏​⁡⁠⁡‌⁢⁢​‎‎⁡⁠⁢⁡⁡‏⁠‎⁡⁠⁢⁡⁢‏⁠‎⁡⁠⁢⁡⁣‏⁠‎⁡⁠⁢⁡⁤‏⁠‎⁡⁠⁢⁢⁡‏⁠‎⁡⁠⁢⁢⁢‏⁠‎⁡⁠⁢⁢⁣‏‏​⁡⁠⁡‌⁢⁣​‎‎⁡⁠⁣‏⁠‎⁡⁠⁤⁣‏⁠‎⁡⁠⁤⁤‏‏​⁡⁠⁡‌⁢⁤​‎⁠⁠⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏⁠‎⁡⁠⁤⁢‏⁠‏​⁡⁠⁡‌⁣⁡​‎‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏⁠‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏‏​⁡⁠⁡‌⁣⁢​‎‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏‏​⁡⁠⁡‌­
                                ⌈2⍟⍵+1   # ‎⁡Add 1 to input (just to prevent 0) and find log base 2, rounding up
                              1⌈         # ‎⁢Find max between that and 1 to ensure we always have at least one digit to look at
                           2⍴⍨           # ‎⁣Get that many 2's
                        ⍵⊤⍨              # ‎⁤and encode the input, base-2
 {                     }                 # ‎⁢⁡Then check that
                1=+/0=⍵                  # ‎⁢⁢The count of 0's is 1
  (           )∧                         # ‎⁢⁣AND
     ⍵[      ]                           # ‎⁢⁤The value at
       ⌈2÷⍨≢⍵                            # ‎⁣⁡  the center of the array
   0=                                    # ‎⁣⁢is zero
💎

Created with the help of Luminespire.

AWK, 94 92 97 bytes

$1{for(;$1;$1=int($1/2))x=$1%2x
for(;i++<l=split(x,a,X);)b[a[i]]++}$0=1~b[0]&&!a[int(l/2)+1]&&l%2

Try it online!

TIO doesn't like this one. Prints 1 if cyclops else nothing.

awk '$1{for(;$1;$1=int($1/2))x=$1%2x;for(;i++<l=split(x,a,X);)b[a[i]]++}$0=(1~b[0]&&!a[int(l/2)+1])&&l%2' <<< 119

$1{                            # check inputs > 0
for(;$1;$1=int($1/2))x=$1%2x;  # convert to binary
for(;i++<l=split(x,a,X);)      # split digits
b[a[i]]++}                     # count 1s and 0s
$0=                            # set output to 1 if
1~b[0]                         # only one instance of 0
&&!a[int(l/2)+1]               # and it's in the middle
&&l%2                          # and odd # of digits

Here's an exhaustive search (skipping 0):

BEGIN{for(;++j;){x=""
for(h=j;h;h=int(h/2))x=h%2x
for(i=0;i++<l=split(x,a,X);)b[a[i]]++
if(1~b[0]&&!a[int(l/2)+1]&&l%2)print j
b[0]=b[1]=0}}

Interestingly, it appears to be a series where the next number is approaching 4 times greater than the last:

5
27:5.4
119:4.40741
495:4.15966
2015:4.07071
8127:4.03325
32639:4.01612
130815:4.00794
523775:4.00394
2096127:4.00196
8386559:4.00098

Found these quickly simply by modifying algo to jump 4x after a hit:

33550335:4.00049
134209535:4.00024
536854527:4.00012
2147450879:4.00006
8589869055:4.00003
34359607295:4.00002

Vyxal, 8 bytes

ʀE:²d‹εc

Try it Online!

Different approach, constructing the list of cyclops numbers mathematically:

b1110111 = b1111111 - b1000 = b10000000 - b1000 - 1 = 2^7 - 2^3 - 1
1{n}01{n} = 1{2n+1} - 10{n} = 2^(2n+1) - 2^n - 1

so the cyclops numbers are of the form \$2^{2n+1}-2^n-1\$.

       c # Is the input any of
ʀ        # For all k in [0, n]
 E       # 2^k
   ²d    # 2^(2k+1)
      ε  # - 
  :      # 2^k
     ‹   # - 1

Uiua, 11 bytes

≍-⊸/↧≠⇌.°⊏⋯

Try it: Uiua pad

Explanation:

                    5        10         15         27         
⋯     bits          [1 0 1]  [0 1 0 1]  [1 1 1 1]  [1 1 0 1 1]
°⊏    length-range  [0 1 2]  [0 1 2 3]  [0 1 2 3]  [0 1 2 3 4]
⇌.    reverse       [2 1 0]  [3 2 1 0]  [3 2 1 0]  [4 3 2 1 0]
≠     not equal     [1 0 1]  [1 1 1 1]  [1 1 1 1]  [1 1 0 1 1]
-⊸/↧  subtract min  [1 0 1]  [0 0 0 0]  [0 0 0 0]  [1 1 0 1 1]
≍     match?        1        0          0          1

Japt, 8 bytes

Adding to the collection of 8-byte Japt solutions; can't seem to come up with anything shorter.

¢¶¢Ôp¢èT

Try it (Includes all test cases)

¢¶¢Ôp¢èT     :Implicit input of integer U
¢            :Convert to binary
 ¶           :Check for equality with
  ¢Ô         :  Convert U to binary and reverse
    p        :  Repeated
     ¢è      :    Convert U to binary and count the occurrences of
       T     :      0

Uiua, 17 characters (32 bytes UTF-8)

↥↧≍⇌.∶=1/+¬.⋯∶=0.

Explanation of ungolfed version:

↥⊃(↧⊃(≍⇌.)(=1/+¬)⋯)(=0)­⁡​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏⁠⁠⁠⁠⁠‎⁡⁠⁢⁡⁤‏⁠‎⁡⁠⁢⁢⁡‏⁠‎⁡⁠⁢⁢⁢‏⁠‎⁡⁠⁢⁢⁣‏‏​⁡⁠⁡‌⁢​‎⁠‎⁡⁠⁢⁡⁢‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏⁠‎⁡⁠⁤⁢‏⁠‎⁡⁠⁤⁣‏⁠‎⁡⁠⁤⁤‏⁠‎⁡⁠⁢⁡⁡‏⁠‏​⁡⁠⁡‌⁤​‎⁠⁠‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏⁠‎⁡⁠⁢⁢‏⁠‎⁡⁠⁢⁣‏⁠‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏‏​⁡⁠⁡‌­
↥⊃                   (=0)  # ‎⁡n is zero, or
                  ⋯       # ‎⁢the binary expansion of n
   ↧⊃      (=1/+¬)         # ‎⁣sums to 1 when all its bits are flipped
   ↧⊃(≍⇌.)                # ‎⁤and matches itself reversed

Vyxal, 55 bits^v2, 6.875 bytes

b†Ḃ₍⁼∑≈

Try it Online!

Bitstring:

0111000000100000010011101011101001010010110100100111000

b†Ḃ₍⁼∑≈­⁡​‎‎⁡⁠⁡‏⁠‎⁡⁠⁢‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁣‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁤‏⁠⁠⁠‎⁡⁠⁢⁣‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁢⁡‏⁠⁠‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁢⁢‏‏​⁡⁠⁡‌⁢⁢​‎‏​⁢⁠⁢‌⁢⁣​‎‏​⁢⁠⁢‌­
b†       # ‎⁡Convert to binary, then invert each bit
  Ḃ      # ‎⁢Push the list of inverted bits and its reverse
   ₍  ≈  # ‎⁣is each item in the list equal?
    ⁼    # ‎⁤does the reverse of the inverted bits equal the inverted bits
     ∑   # ‎⁢⁡sum of the bits
‎
💎

Created with the help of Luminespire.

7 byter (before encoding) with a completely different method.

Edit: Apparently this is a port of Jelly but I didn't realize

‎⁢⁣Since the equality check can only be 0 or 1, and the sum of the inverted bits is always at least 1 for any nonzero number, the values can only be equal if there is exactly one "1" in the inverted binary representation and that "1" is directly in the middle

Thunno 2, 8 bytes

ḃDḲ=s0c=

Attempt This Online!

Port of emirps's Vyxal answer.

Explanation

ḃDḲ=s0c=  # Implicit input
ḃD        # Convert to binary; duplicate
  Ḳ=s     # Check if palindrome; swap
     0c=  # Equals the count of 0s?
          # Implicit output

Vyxal, 8 bytes

Π:Ḃ=$0O=

Try it Online!

Different approach from the other Vyxal answer.

Π        # binary of input
  Ḃ=     # the equality of the reversed version of it to itself (0 for non palindrome, 1 for palindrome)
       = # is equal to
 :  $0O  # the count of 0s in itself

Could potentially be golfed

Thunno, \$ 8 \log_{256}(96) \approx \$ 6.58 bytes

bDZqs0c=

Attempt This Online!

Port of emirps's Vyxal answer.

Thunno P, \$ 9 \log_{256}(96) \approx \$ 7.41 bytes

bD0c1=sZq

Attempt This Online!

Port of Kevin Cruijssen's 05AB1E answer.

Explanation

bDZqs0c=  # Implicit input
bD        # Convert to binary and duplicate
  Zqs     # Check if it's a palindrome and swap
     0c=  # Is this equal to the count of 0s?
          # Implicit output

bD0c1=sZq  # Implicit input
bD         # Convert to binary and duplicate
  0c       # Count the number of "0"s in the string
    1=     # Is it equal to 1?
      sZq  # Swap and check if it's a palindrome
           # P flag multiplies them together
           # Implicit output

GolfScript, 31 35 26 bytes

-5 thanks to @DLosc

.!5*+2base..-1%=\{0=},,1=&

Link includes test cases.

Try it online!

Explanation

.!5*+2base..-1%=\{0=},,1=& | whole program
.!5*+                      | if the input is 0, make it 5 (smallest non-zero cyclops number)
     2base..               | push the binary version of the input
            -1%            | push the reversed version of the binary
               =           | is it equal to the non-reversed version?
                \{0=},,    | count the number of zeros 
                       1=  | is it equal to 1?
                         & | are both of the above checks true?

Java 8, 66 ⁶⁹ bytes

-3 bytes thanks to @ceilingcat !

n->{int r=0,i=0;for(;i<16;)r+=n-~(1<<i)==1<<i+++i?1:0;return r>0;}

Try it online!

Don't hesitate to ask if this needs any explanation!

Alternative solution really close using Streams (70 bytes) :

n->"0123456789:;<=>?".chars().anyMatch(e->n-~(1<<e-48)==1<<2*(e-48)+1)

Erlang 37 bytes

f(x)->Y=2*X bxor (2*X+3),Y*Y==8*X+9.

Swift 5.7, 60 bytes

{nil != (try?#/(1+)0\1/#.wholeMatch(in:String($0,radix:2)))}

SwiftFiddle link

Swift 5.7 introduced Regex literals, delimited by #/.../#. This code attempts to match the regex (1+)0\1 against the string, and returns whether or not it succeeded. Input may be any BinaryInteger.

I'm not certain that this is shorter than bit manipulation, but this is shorter than the existing answer.

Vyxal, 9 bytes

b0₌O€vL≈=

Try it Online!

Output 0 → False, 1 → True

b         # To binary array
 0        # Push 0
  ₌       # Parallel apply next two operators:
   O      #   Count how many "0" and
    €     #   Split at "0"
     vL   # Lengths of parts
       ≈  # If its equal return 1
        = # If its equal number of zeroes, return 1, else 0

><>, 45 bytes

!v:2%$2,:1%-:1(?!
1\~
*>l2=?vl3=?0${*
$0=*n;>

Try it online!

Pyt, 17 bytes

ĐļƖĐ⁺2⇹^⇹ᵮ₂2⇹^-⁻=

Try it online!

No string manipulation required

ĐļƖĐ⁺2⇹^⇹₂2⇹^-⁻=

PHP, 74 bytes

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

Try it online!

Or 61 bytes using Arrow syntax:

fn($x)=>($c=strlen($a=decbin($x)))&1&trim($a,1)===$a[$c/2|0];

Try it online!

Totally naïve non-mathematical approach, just strings.

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
                           // string with left and right 1's removed? (can only be '0')
}

Or 60 bytes based on @Chronocidal's algorithm above.

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

Try it online!

Burlesque, 21 bytes

b2JXXRA'0==j'0CN1==&&

Try it online!

b2   # As binary
J    # Duplicate
XX   # Split into chars (RA is supposed to work with strings but doesn't)
RA   # Get middle
'0== # Is 0
j    # Reorder stack
'0CN # Count of 0s
1==  # ==1
&&   # And

Shorter, but sadly doesn't work for zero case because 2dg returns empty list

Burlesque, 16 bytes

2dgJRAj0CN-.||n!

Try it online!

2dg # Base 2 as list of digits
J   # Duplicate
RA  # Get middle
j   # Reorder stack
0CN # Count 0s
-.  # Decrement (i.e 1 -> truthy, else falsy)
||n!# not or (Check both zero) 

Zsh --extendedglob, 30 bytes

>$[[##2]$1]
<`ls|rev`~*0*0*~1#

Attempt This Online!

Outputs via exit code (0 = is a cyclops number, 1 = not a cyclops number).

• > - create the file
  • $[[##2]$1] - the input in base 2
• <`ls|rev`~00*~1# - try to find a file that matches this pattern:
  • `ls|rev` - the file in reverse (i.e. palindromic)
  • ~ - but not this pattern
    • *0*0* - more than one 0
  • ~ - and not this pattern either
    • 1# - one or more 1s

The exit code depends on whether or not the pattern matched and the file could be found.

Regex (ECMAScript), 60 58 57 60 58 bytes

The input \$n\$ is in unary, as the length of a string of xs.

SPOILER WARNING: For the square root, this regex uses a variant of the generalized multiplication algorithm, which is non-obvious and could be a rewarding puzzle to work out on your own. For more information, see an explanation for this form of the algorithm in Find a Rocco number.

-2 bytes by allowing backtracking in the search for \$z\$
-1 byte thanks to Grimmy, by searching for \$z\$ from smallest to largest instead of vice versa
+3 bytes to handle zero
-2 bytes by moving the square root capture outside the lookahead

This works by finding \$z\$, a perfect square power of 2 for which \$n=2(n-z)+\sqrt{z}+1\$. Only the largest perfect square power of 2 not exceeding \$n\$ can satisfy this, but due to a golf optimization, the regex tries all of them starting with the smallest. Since each one corresponds to a cyclops number, only the largest one can result in a match.

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

Try it 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

Regex (ECMAScript), 53 47 bytes

-6 bytes thanks to both Deadcode and Grimy

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

Try it online!

_{^{explanation by Deadcode}}

This regex takes its input in unary, as a sequence of x characters in which the length represents the number. Properties of its binary representation are handled indirectly, by doing math on its unary representation.

It works by looping the following operation, which is a subtraction at every step:

• Trim the leftmost and rightmost 1 from the number's binary representation, if the 1 being trimmed from the left is immediately followed by another 1 or the full number is 101

If and only if the initial input was a cyclops number, it will be the next smallest cyclops number at every step of the loop, e.g. 1110111 → 11011 → 101 → 0. The regex matches if and only if the value is 0 at the end.

^                              # tail = N, the input number
(                              # While tail is odd and is >= 3, and has a leftmost "11"
                               # in its binary representation, trim off the leftmost and
                               # rightmost 1 from its binary representation. If it is a
                               # cyclops number, it will be the next smaller cyclops
                               # number on the next iteration.
    (?=
        (x*?)                  # Find the smallest \2 such that tail - 2*\2 satisfies the
                               # following assertion, i.e. that tail - 2*\2 = 2^k-1
                               # where k >= 2. In other words, assert tail is odd, and
                               # let \2 = (tail - 2^k + 1) / 2, where 2^k-1 has the
                               # largest value of k such that 2^k-1 <= tail. If tail is
                               # a cyclops number, then \2-1 will be the next smallest
                               # cyclops number;
                               # tail -= \2
        (                      # \3 = tool to make tail-1 = \2-1 (will be used later)
            \2                 # tail -= \2
            ((x+)x(?=\5$))+x$  # Assert tail = 2^k-1 where k >= 2
        )
    )
    (?!\2{6})                  # Assert that tail < 6*\2, which is a way of asserting
                               # that in tail's binary representation, the next 1 to the
                               # right of the one we'll be trimming is also 1. This
                               # prevents for example, trimming 10110111 -> 11011, which
                               # would give us a false positive. As a worst case example,
                               # let's say tail = 0b101111111111111111111111111111111111
                               # this would give us:
                               #             \2 = 0b001000000000000000000000000000000000
                               #           6*\2 = 0b110000000000000000000000000000000000
                               # So it's not quite exactly asserting that tail begins
                               # with "11" in its binary representation, and would
                               # continue looping in that case, but that doesn't matter
                               # because that number could never be trimmed into a
                               # cyclops number anyway. With any smaller value of tail
                               # that passes the other tests, we'd have:
                               #           tail = 0b101111111111111111111111111111111101
                               #             \2 = 0b000111111111111111111111111111111111
                               #           6*\2 = 0b101111111111111111111111111111111010
                               # and in this case tail >= 6*\2, so it stops the loop.
                               # On the other end of the scale is 0b101, which needs to
                               # be trimmed even though it doesn't have two leftmost 1
                               # bits in a row. And indeed, that works:
                               #           tail = 0b101
                               #             \2 = 0b001
                               #           6*\2 = 0b110
                               # In this case, it is just barely true that tail < 6*\2
                               # and the loop is allowed to continue one more step.
    \3x                        # tail = \2-1
)*
$                              # Assert that tail = 0 after the loop finished. This will
                               # be true iff N is a cyclops number. If it fails to match,
                               # backtracking cannot make it match, because everything in
                               # the loop is atomic.

C++ (clang), 72 68 67 60 bytes

As with Neil's and Grimmy's solutions, this works by asserting that the input is of the form \$(2^k-1)(2^{k+1}+1)\$.

5 bytes were dropped thanks to Arnauld, by changing ((x)+1) to -~(x) and ((x)-1) to ~-(x), and then changing n-a*-b to n+a*b. An additional 7 bytes were dropped thanks to ceilingcat.

int f(int n){int z,k=1;while((z=n+~-k*~(k*=2))>0);return!z;}

Try it online!

Alternative 60 byter:

int f(int n){for(int o=n,k=1;n>0;)n=o+~-k*~(k*=2);return!n;}

Try it online!

Ungolfed:

bool is_cyclops_number(int n)
{
    for (int k=1;; k*=2)
    {
        int z = n - (k - 1) * (k*2 + 1);
        if (z == 0)
            return true;
        if (z < 0)
            return false;
    }
}

C (gcc) - x86 & most others, 41 34 bytes

Returns zero for true and nonzero for false.

k;f(n){for(k=1;n+~-k*~(k*=2)>0;);}

Try it online!

This demonstrates why I hate the implicit accumulator return value exploit that is commonly used in C submissions and less often in C++ submissions. It's fragile and very much architecture dependent. Here, it depends upon the comparison operator > not changing the value of the accumulator.

I did notice something quite curious regarding the ARM gcc assembly code. It appears that the return value hack is being explicitly supported, by copying the intermediate result r3, which wasn't stored into any variable, into the accumulator r0 once the loop is done:

        cmp     r3, #0
        bgt     .L2
        nop
        mov     r0, r3

Similarly on PowerPC gcc, where register 3 carries the return value:

        cmpwi 7,9,0
        bgt 7,.L2
        mr 3,9

Similarly on RISC-V gcc, where a0 carries the return value:

       add   a5,a5,a4
       bgtz  a5,10144 <f+0x12>
       nop
       mv    a0,a5

In fact, it appears the trick works on all but one of the architectures on godbolt. On MSP430 gcc 6.2.1, it yields the code with the equivalent of return 0 (as the return value is passed through R12):

        MOV.B   #0, R12
        CMP.W   R13, R12 { JL .L2
        NOP

C++ (gcc), ^{142 \$\cdots\$ 59} 55 bytes

Saved 10 a whopping 21 23 bytes thanks to ceilingcat!!!

int f(int n){int c=__builtin_ctz(~n);n=(n>>c)+2==2<<c;}

Try it online!

Ungolfed:

bool is_cyclops(int n)
{
    int ones = 1;
    while ((n & 1) == 1)
    {
        ++ones;
        n /= 2;
    }
    while (--ones, n /= 2, (n & 1) == 1)
    {
        // nothing to do
    }
    return n == 0 && ones == 0;
}

Pip, 15 bytes

YTBa^0 2=#y&$=y

Try it online!

A much shorter pip solution.

Explanation

YTBa^0 2=#y&$=y a → input integer
YTBa^0         Yank binary representation of a into var y, split on 0's
       2=#y     Length of y = 2?
           &$=y and all items of y are equal?
                Implicit output of boolean

Mathematica (Wolfram language), 32 31 bytes

1 byte saved thanks to J42161217!

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

Try it online!

Pure function taking an integer as input and returning True or False. Based on the fact (fun to prove!) that a number n is Cyclops if and only if n plus the square root of n/2 plus 2 rounds down to an odd power of 2. (One can replace Floor by either Ceiling or Round as long as one also replaces +2 by +1.) Returns True on input 0.

Gaia, 10 9 bytes

b:ṭ¤0C1=∧

Try it online!

Verify All Test Cases

b:		% convert to binary and dup
  ṭ		% is it a palindrome?
        ∧	% and
   ¤0C		% is the count of zeros
      1=	% equal to 1?
		% implicit print top of stack

Pip, 87 bytes

a:qTa<=1{((a%2)=0)?(x:"0".x)(x:"1".x)a//:2}1=a?x:"1".xsc:x^"0"x=0|#x%2=1&(c0)=(c1)&#c=2

Try it online!

J, 22 19 17 15 14 bytes

-3 bytes thanks to BolceBussiere !

-4 bytes thanks to ngn!

-1 byte thanks to Traws!

J, 14 bytes

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

Try it online!

C (gcc),  29 28  27 bytes

Saved 1 byte thanks to @ceilingcat

A port of the 21-byte JS answer by @tsh.

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

Try it online!

dc, 62 60 bytes

[2~rd0<B]dsBx1kz2/szsi[1r-si]sC[zlz=Cli*siz0<M]sMz1=Cz1<Mlip

Try it online!

dc has no native truthy/falsy values (conditionals either execute a macro or they don't); using 1 for truthy and 0 for falsy, I hope that's ok.

[2~rd0<B]dsBx          # Basic breakdown into binary. Every digit is a stack entry. Luckily this
                       # also leaves an extra 0 on the stack.
1k                     # Set precision to one - needed it at 0 for the binary-ifier.
z2/sz                  # Divide the stack depth by 2 and store it in 'z'. This is why we're lucky
                       # that the binary-ifier leaves an extra bit on the stack! Numbers with even 
                       # numbers of binary digits will now have an odd number & this value will be
                       # (whatever).5 which... isn't a valid stack depth.
si                     # Seed 'i' which is our truthiness register w/ that extra 0
[1r-si]sC              # Macro 'C' toggles the top of stack between 0 and 1 by subtracting it from 1.
                       # It stores this in 'i'. This is the only way 'i' ever becomes 1.
[zlz=Cli*siz0<M]sM     # First we test if we're at the position of the stack that matches up with 
                       # 'z', and run 'C' if so. Thus, if we're in the 'Cyclops' position (the
                       # middle), we'll flip that from a 0 to a 1 or vice versa. Next we load 'i'
                       # and multiply it by top of stack, putting that back in 'i'. For the first half
                       # this whole thing does nothing but multiply stuff by zero. In the middle
                       # position (if there is one) it sets 'i' to 1 if it's a zero. For the rest of
                       # the digits, it multiplies by '1' if things are ok, and '0' if there's another
                       # (Cyclops-invalidating) zero.
z1=Cz1<M               # 1 and 0 don't work w/o special treatment. Run 'C' if it's one of these, 
                       # otherwise start 'M'
lip                    # Print 'i'

Golfed off two bytes because my brain was fried and I was using a wasteful, convoluted method of toggling between 1 and 0.

K (ngn/k), 19 bytes

{1=(~x)+/~a&|a:2\x}

Try it online!

{ } function with argument x

2\x the bits of x

a: assign to a

a&|a and between a and its reverse (|a)

~ not

+/ sum

(~x) use "not x" as the initial value for the sum. this is to correct for 2\x returning an empty list of bits when x is 0

1= compare with 1

Perl 6 (26 bytes)

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

Java, 96 bytes

n->{String[]a=Integer.toBinaryString(n).split("0");return n==0||a.length==2&&a[0].equals(a[1]);}

Try it online!

PHP

The shortest code should be this:

preg_match('`^(?<l>1*)0\k{l}$`', decbin($n));

Here the script to test it:

$inputs = [
    0,
    1,
    5,
    9,
    10,
    27,
    85,
    101,
    111,
    119,
];


function isCyclop($n) {
    return preg_match('`^(?<l>1*)0\k{l}$`', decbin($n));
}

foreach ($inputs as $input) {
    echo "$input : ".(isCyclop($input)?'truthy':'falsy').PHP_EOL;
}

Factor, 69 bytes

: f ( n -- ? ) >bin [ dup reverse = ] [ [ 48 = ] count 1 = ] bi and ;

Try it online!

Japt, 8 bytes

1¥¢q0 äè

Run it online

Explanation:

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                                         

The idea is to split the binary string at 0, which would yield two items if there is only one 0. Then we see if the first item matches the second to ensure it is palindromic. If the binary string contains multiple 0s, then the reduce would return a multi-item array and that would fail the ==1 condition. If the binary string does contain one 0, but is not palindromic, äè will return 0 because b contains 0 matches of a.

Java, 201 bytes (compilable)

Hmm, a different approach in java, runnable on commandline (so there is much to cut out).

class Z{public static void main(String[]a{a=Integer.toBinaryString(Integer.valueOf(a[0])).split("0");System.out.println(a.length==0?1:(a.length!=2?1:a[0].length()-a[1].length()+a.length-2)==0?1:0);}}

prints 0 for non cyclops and 1 for cyclops numbers.

JavaScript (Node.js), 20 bytes

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

Try it online!

Maybe this is correct, maybe.

Thanks Grimy, 1 byte saved.

JavaScript (Node.js), 32 bytes

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

Try it online!

JavaScript (Node.js), 34 bytes

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

Try it online!

Brachylog, 8 bytes

ḃD↔Dḍ×ᵐ≠

This is a predicate that succeeds if its input is a Cyclops number and fails if its input is not a Cyclops number. Success/failure is the most fundamental truthy/falsey concept in Brachylog.

Try it online! Or, find all truthy outputs up to 10000.

Explanation

          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

This succeeds only when given a Cyclops number, because:

• If the binary representation isn't a palindrome, D↔D will fail; in what follows, we can assume it's a palindrome.
• If there is more than one zero, both halves will contain at least one zero. So the products will both be zero, and ×ᵐ≠ will fail.
• If there is no zero, both halves will contain only ones. So the products will both be one, and ×ᵐ≠ will fail.
• That leaves the case where there is exactly one zero; since we already know we have a palindrome, this must be the central bit. It will appear in one half, causing that half's product to be zero; the other half will contain all ones, so its product will be one. Then we have 1 ≠ 0, ×ᵐ≠ succeeds, and the whole predicate succeeds.

Retina 0.8.2, 38 37 bytes

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

Try it online! Link includes test cases. Edit: After clarification, previous solution didn't handle zero correctly. Explanation:

.+
$*

Convert from decimal to unary.

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

Convert from unary to binary, using the method from the Retina wiki.

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

Check for the same number of 1s before and after the 0, or an empty string (which is how the above conversion handles zero).

x86 Machine Code, 17 bytes

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

The above bytes define a function that accepts a 32-bit integer input value (in the EDI register for this example, following a common System V calling convention, but you could actually pick pretty much any input register you wanted without affecting the size of the resulting code), and returns a result (in the EAX register) indicating whether the input value is a Cyclops number.

The input is assumed to be an unsigned integer, since the challenge rules state that we can ignore negative values.

The decision logic is borrowed from Neil's answer: since a Cyclops number has the form \$ n = (2 ^ k + 1) (2 ^ { k - 1 } - 1) \$, we can use a series of bit-twiddling operations to check the input.

Note: The return value is truthy/falsy, but the semantics are reversed, such that the function will return falsy for a Cyclops number. I claim this is legal because machine code doesn't have "specifications for truthy/falsy", which is the requirement in the question. (See below for an alternative version if you think this is cheating.)

In assembly language mnemonics, this is:

; 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

Try it online!

As promised, if you think it's cheating to invert the semantics of truthy/falsy even in machine code where there are no real standards or conventions, then add three more bytes, for a total of 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

The first half of this code is the same as the original (down through the imul instruction). The lea is almost the same, but instead of adding a constant 2, it only adds a constant 1. That's because the following inc instruction increments the value in the EAX register by 1 in order to set the flags. If the "zero" flag is set, the setz instruction will set AL to 1; otherwise, AL will be set to 0. This is the standard way that a C compiler will generate machine code to return a bool.

Changing the constant added in the lea instruction obviously doesn't change the code size, and the inc instruction is very small (only 1 byte), but the setz instruction is a rather whopping 3 bytes. Unfortunately, I can't think of any shorter way of writing it.

Stax, 9 7 bytes

ç8┤-½Θ■

Run and debug it

APL(NARS), 57 char, 114 bytes

{⍵≤0:1⋄k=m←⌈k←2÷⍨≢v←{(2⍴⍨⌊1+2⍟⍵)⊤⍵}⍵:0⋄((,1)≡∪v∼⍦0)∧∼m⊃v}

test:

  f←{⍵≤0:1⋄k=m←⌈k←2÷⍨≢v←{(2⍴⍨⌊1+2⍟⍵)⊤⍵}⍵:0⋄((,1)≡∪v∼⍦0)∧∼m⊃v}
  ⎕fmt f¨0 1 5 12 27 85 101 119
┌8───────────────┐
│ 1 0 1 0 1 0 0 1│
└~───────────────┘

This below would be (modulus bugs) the function that would convert a positive integer number omega in one array of digits in base alpha:

{(⍺⍴⍨⌊1+⍺⍟⍵)⊤⍵}

Haskell, 32 bytes

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

Try it online!

Python 2, 30 bytes

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

Try it online!

Note that 2*n^2*n+3 is the bitwise xor of 2*n and 2*n+3, because that's Python's operator precedence.

Japt, 25 19 10 9 bytes

¢êÅ©1¶¢èT

Thanks to @Shaggy for -1 byte

Try it online!

Perl 5 -p, 32 bytes

$_=(sprintf'%b',$_)=~/^(1*)0\1$/

Try it online!

Haskell, 82 bytes

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

And a port of xnor's Python solution:

Haskell, 47 bytes

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

Swift, 161 bytes

func c(a:Int)->Int{
    let b=String(a,radix:2)
    let f=b.firstIndex(of:"0")
    return a>=0 && f==b.lastIndex(of:"0") && f?.encodedOffset==b.count/2 ? 1 : 0
}

Try it online!

VBA, 41 36 Bytes

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

Run in the Immediate window, with Explicit Declaration turned off. Input is cell A1 of the active sheet. Outputs True/False to the immediate window.

Uses the same logic as my Excel Answer to find the Cyclops number of the same number of bits (or 1 bit shorter if there are an even number!) and then compares that with the input.

Saves some bytes when calculating Cyclops numbers by reducing them to the form y = 2x^2 - x - 1 (where x = n-1 for the nth Cyclops number, or x = 2^Int(Log([A1])/Log(4)) to find the largest Cyclops number with a lesser-or-equal number of bits) and storing x in a variable

(-5 Bytes thanks to Taylor Scott!)

Jelly,  8  7 bytes

-1 thanks to Erik the Outgolfer (use isPalindrome built-in, ŒḂ, instead of ⁼Ṛ$)

B¬ŒḂ⁼SƊ

A monadic Link accepting an integer which yields 1 (truthy) or 0 (falsey).

Try it online!

How?

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

C (gcc), 26 bytes

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

Try it online!

Port of Neil's answer. Relies on implementation-defined ordering of operations.

C++ (clang), 38 bytes

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

Try it online!

Can't omit the types in C++, can’t omit the return in clang, otherwise identical.

Java (OpenJDK 8), 135 130 bytes

Uses the Formula described here: A129868

(n)->java.util.stream.IntStream.range(0,16).map(r->((Double)(Math.pow(2,2*r+1)-(Math.pow(2,r)-1)-2)).intValue()).anyMatch(c->c==n)

Try it online!

Japt, 8 bytes

¢ðT ¥¢Êz

Thanks to Luis felipe de Jesus Munoz for fixing my submission!

Try it Online!

Old regex-based solution, 15 bytes

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

Returns 1 for true, 0 for false.

Try it Online!

Regex (ECMAScript), 65 59 57 58 bytes

+1 byte to handle 0 correctly

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

Try it online!

Works by asserting the input is of the form \$ (2^k - 1) (2^{k+1} + 1) \$. Ties Deadcode's answer but with a completely different algorithm.

Attache, 22 bytes

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

Try it online!

Alternatives

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

R, 37 33 bytes

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

Try it online!

R doesn't have a built-in for converting to binary, so I simply used one of the formulae from OEIS to calculate a list of terms from the sequence.

n<-0:x generates a generous list of starting values. 2*4^(n<-0:x^2)-2^n-1) is the formula from OEIS, and then it checks whether the input appears in that sequence using %in%.

-2 bytes by not having to handle negative inputs. -2 bytes by remembering I can change <- to =.

Excel, 101 107 bytes

-6 bytes thanks to @Chronocidal.

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

Performs 3 checks:

• Odd length

ISEVEN(LOG(A1,2))

• Middle character is 0

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

• There is a single 0

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

Excel, 97 63 Bytes

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

Calculates 2 numbers:

Twice the nearest Power of 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 the square root of the nearest Power of 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

Then subtract the second number from the first:

>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

And compare this result with the original number

Old Method

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

Start with the Log-base-2 of A1 and round it down the nearest even number, then add 1.

Next create a string of that many "1"s, and replace the middle character with a "0" to create a Cyclops number with a binary length that is always odd, and the same as or 1 less than the binary length of A1

Then, compare it with the Binary representation of A1

05AB1E, 8 (or 9) bytes

bD0¢sÂQ*

Try it online or verify all test cases.

Returns 1 if truthy; 0 or any positive integer other than 1 as falsey. In 05AB1E only 1 is truthy and everything else is falsey, but I'm not sure if this is an allowed output, or if the output should be two consistent and unique values. If the second, a trailing Θ can be added so all outputs other than 1 become 0:

Try it online or verify all test cases.

Explanation:

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)

An arithmetic approach would be 10 bytes:

LoD<s·>*Iå

Try it online or verify all test cases.

Explanation:

Creates a sequences using the algorithm \$a(n) = (2^n-1)*(2*2^n+1)\$, and then checks if the input-integer is in this sequence.

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)

Ruby, 27 24 bytes

Convert to binary and check with a regex. Returns 0 if true, nil if false.

-3 bytes thanks to GB.

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

Try it online!

For two bytes more, there's a direct port of the Python solution:

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

Ruby, 24 bytes

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

Try it online!

Batch, 39 37 bytes

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

Explanation: A Cyclops number has the form \$ n = (2 ^ k + 1) (2 ^ { k - 1 } - 1) \$. The bitwise XOR then results in \$ m = 2 ^ k - 1 \$ from which we can recalculate \$ n = \lfloor \frac m 2 \rfloor ( m + 2 ) \$. This can then be used to test whether \$ n \$ was a Cyclops number.

Jelly, 9 bytes

BŒḂaB¬S=1

Try it online!

Perl 6, 23 bytes

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

Try it online!

Regex based solution