任务：

给定一个整数输入，找出它是否是一个独眼巨人数。

您可能会问，什么是独眼巨人号码？嗯，这是一个数字，其二进制表示0的中间只有一个！

测试用例：

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

输入：

• 整数或等效类型。（int，long，decimal等）

• 假定如果评估输入结果导致整数溢出或其他不良问题，则不必评估该输入。

输出：

• 真实或虚假。

• 真实/虚假输出必须符合所用语言的真实/虚假规范。（例如，C的0值为false，非零的值为true）

挑战规则：

• 小于0的输入被认为是虚假的，因此不必进行评估。

• 如果数字的二进制表示形式的长度为偶数，则该数字不能为独眼巨人数字。

通用规则：

• 这是代码高尔夫球，因此最短答案以字节为单位！

• 禁止默认漏洞。

• 标准规则适用于具有默认I / O规则的答案。

这是我的第一个程序设计难题和代码高尔夫挑战赛，因此，对我应该如何改进的任何反馈将不胜感激！

Japt，8个字节

1¥¢q0 äè

在线运行

说明：

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                                         

这个想法是将二进制字符串拆分为0，如果只有一个，它将产生两个项目0。然后，我们查看第一项是否与第二项匹配以确保其回文性。如果二进制字符串包含多个0s，则reduce将返回一个多项目数组，这将使==1条件失败。如果二进制字符串确实包含1 0，但不是回文，äè则将0由于b包含的0匹配项而返回a。

Python 2，30个字节

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

在线尝试！

请注意，这2*n^2*n+3是和的按位异2*n或2*n+3，因为这是Python的运算符优先级。

x86机器码，17个字节

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

上面的字节定义了一个接受32位整数输入值的函数（在EDI此示例的寄存器中，遵循通用的System V调用约定，但是实际上您可以选择几乎任何所需的输入寄存器，而不会影响结果的大小代码），并返回结果（在EAX寄存器中），指示输入的值是否为独眼巨人数。

假定输入为无符号整数，因为质询规则指出我们可以忽略负值。

决策逻辑从借用尼尔的答案：因为水蚤号码的形式$n = (2 ^ k + 1) (2 ^ { k - 1 } - 1)$，我们可以使用一系列位变换操作以检查输入。

注意：返回值是true / falsy，但是语义相反，因此该函数将为Cyclops数字返回falsy。我声称这是合法的，因为机器代码没有“真/假规范”，这是问题中的要求。（如果您认为这是作弊的，请参见下面的替代版本。）

在汇编语言助记符中，这是：

; 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

在线尝试！

如承诺的那样，如果您认为即使在没有真正标准或约定的机器代码中，也要颠倒true / falsy的语义，然后再添加三个字节，总共21个字节：

; 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

该代码的前半部分与原始代码相同（在imul指令中向下）。的lea几乎是相同的，但不是加上一个常数2，它仅增加了一个常量1.这是因为下面的inc指令递增在值EAX1，以设置的标志寄存器。如果设置了“零”标志，则setz指令将设置AL为1；否则，该指令将设置为1。否则AL将设置为0。这是C编译器生成机器代码以返回a的标准方式bool。

更改在lea指令中添加的常量显然不会更改代码大小，并且inc指令非常小（仅1个字节），但该setz指令却是3个字节。不幸的是，我想不出任何更短的编写方法。

正则表达式（ECMAScript），60 58 57 60 58字节

$n$x

SPOILER警告：对于平方根，此正则表达式使用广义乘法算法的一种变体，该算法不明显，可能是您自己解决难题的难题。有关更多信息，请参阅“ 查找Rocco编号”中对此算法形式的说明。

-2字节，允许在搜索回溯$z$
$z$从最小到最大而不是反之亦然
+3 字节通过将平方根捕获移到超前区域来处理零
-2字节

$z$$n=2(n-z)+\sqrt{z}+1$$n$才能满足此要求，但是由于高尔夫的优化，regex会尝试从最小的开始。由于每个对应一个独眼巨人的号码，因此只有最大的一个才可以匹配。

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

在线尝试！

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

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

在线尝试！

也许这是正确的，也许。

感谢Grimy，节省了1个字节。

JavaScript（Node.js），32字节

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

在线尝试！

JavaScript（Node.js），34字节

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

在线尝试！

Perl 6、23个字节

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

在线尝试！

基于正则表达式的解决方案

Japt，25 19 10 9字节

¢êÅ©1¶¢èT

感谢@Shaggy为-1个字节

在线尝试！

Mathematica（Wolfram语言），32 31字节

多亏了J42161217，节省了1个字节！

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

在线尝试！

将整数作为输入并返回Trueor的纯函数False。基于这样的事实（有趣的证明！），一些n是独眼巨人当且仅当n加平方根n/2加上2回合下来到2的奇次幂（其中一个可替代Floor的两种Ceiling或Round只要一个也取代+2通过+1。）返回True输入0。

红宝石，24字节

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

在线尝试！

Japt，8个字节

¢ðT ¥¢Êz

感谢Luis felipe de Jesus Munoz修正了我的提交！

在线尝试！

基于旧正则表达式的解决方案，15字节

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

返回1表示true，0表示false。

在线尝试！

果冻， 8  7 字节

-1感谢Outgolfer的Erik（使用isPalindrome内置的ŒḂ，而不是⁼Ṛ$）

B¬ŒḂ⁼SƊ

1Monadic Link接受一个产生（真实）或0（伪）的整数。

在线尝试！

怎么样？

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个字节

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

在线尝试！

正则表达式（ECMAScript），53 47字节

-6个字节归功于Deadcode和Grimy

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

在线尝试！

Brachylog，8个字节

ḃD↔Dḍ×ᵐ≠

这是一个谓词，如果其输入是独眼巨人数则成功，而如果其输入不是独眼巨人数则失败。成功/失败是Brachylog中最基本的真假概念。

在线尝试！要么，找到不超过10000的所有真实输出。

说明

          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

仅在给定独眼巨人编号时，此操作才能成功，因为：

• 如果二进制表示形式不是回文， D↔D则将失败；在接下来的内容中，我们可以假设这是回文。
• 如果有多个零，则两个半部将至少包含一个零。因此乘积将均为零，并且×ᵐ≠将失败。
• 如果没有零，则两半将只包含一个。因此，产品将都是一个，并且×ᵐ≠会失败。
• 剩下的情况就是恰好有一个零。因为我们已经知道我们有回文，所以这一定是中心。它会出现在一半中，导致该一半的乘积为零；另一半将全部包含，因此其乘积将为一。那么我们有1≠0，×ᵐ≠成功了，整个谓词成功了。

红宝石，27岁 24字节

转换为二进制文件并使用正则表达式检查。0如果为true，则返回nil则 false。

-3个字节，感谢GB。

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

在线尝试！

再加上两个字节，Python解决方案有一个直接端口：

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

05AB1E，8（或9）个字节

bD0¢sÂQ*

在线尝试或验证所有测试用例。

1如果为真，则返回；否则为false。0或除1false 以外的任何正整数。在05AB1E中，仅1是真实的，而其他所有内容都是虚假的，但是我不确定这是否是允许的输出，或者输出是否应该是两个一致且唯一的值。如果第二，后Θ可加入，以便所有输出比其他1成为0：

在线尝试或验证所有测试用例。

说明：

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)

一种算术方法将是10个字节：

LoD<s·>*Iå

在线尝试或验证所有测试用例。

说明：

$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字节

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

计算2个数字：

是2的最接近2的幂
>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加上最接近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

然后从第一个减去第二个数字：

>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

并将此结果与原始数字进行比较

旧方法

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

从A1的Log-base-2开始，将其四舍五入到最接近的偶数，然后加1。

接下来，创建一个包含多个"1"s 的字符串，并将中间字符替换为"0"以创建一个二进制长度始终为奇数且等于或小于A1的二进制长度1的独眼巨人数字

然后，将其与A1的二进制表示形式进行比较

R，37 33字节

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

在线尝试！

R没有内置的转换为二进制的函数，因此我仅使用OEIS中的一个公式来计算序列中的项列表。

n<-0:x生成大量的起始值列表。2*4^(n<-0:x^2)-2^n-1)是OEIS的公式，然后使用以下命令检查输入是否按该顺序出现%in%。

-2字节，不必处理负输入。记住我可以更改<-为-2个字节=。

C（gcc），26个字节

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

在线尝试！

尼尔港的答案。依赖于实现定义的操作顺序。

C ++（clang），38个字节

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

在线尝试！

不能在C ++中省略类型，不能在clang中省略return，否则相同。

C（gcc）， 29 28  27字节

@ceilingcat节省了1个字节

@tsh的21字节JS答案的端口。

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

在线尝试！

J，22 19 17 15 14字节

-3个字节，感谢BolceBussiere！

-4个字节，感谢ngn！

-1字节感谢Traws！

J，14个字节

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

在线尝试！

果冻，9个字节

BŒḂaB¬S=1

在线尝试！

附件，22字节

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

在线尝试！

备择方案

27个字节： {BitXor[2*_,2*_+3]^2=8*_+9}

27个字节： {BitXor@@(2*_+0'3)^2=8*_+9}

27个字节： {Palindromic@_∧1=0~_}@Bin

28个字节： {BitXor[...2*_+0'3]^2=8*_+9}

28个字节： {BitXor[…2*_+0'3]^2=8*_+9}

28个字节： {Same@@Bisect@_∧1=0~_}@Bin

29个字节： {_[#_/2|Floor]=0∧1=0~_}@Bin

30个字节： Same@Bin@{_+2^Floor[Log2@_/2]}

30个字节： {_[#_/2|Floor]=0and 1=0~_}@Bin

视网膜0.8.2，38 37个字节

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

在线尝试！链接包括测试用例。编辑：澄清后，以前的解决方案不能正确处理零。说明：

.+
$*

从十进制转换为一元。

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

使用Retina Wiki中的方法将一元转换为二进制。

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

检查1之前和之后的s 数目是否相同0，或者检查一个空字符串（上述转换如何处理零）。

批处理，39 37字节

@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字节

-6个字节感谢@Chronocidal。

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

执行3个检查：

• 奇数长度

ISEVEN(LOG(A1,2))

• 中间字符是 0

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

• 有一个 0

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

正则表达式（ECMAScript），65 59 57 58字节

+1字节正确处理0

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

在线尝试！

通过断言输入的形式来工作 $(2^k - 1) (2^{k+1} + 1)$

VBA，41 36字节

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

在“立即”窗口中运行，同时关闭“显式声明”。输入是A1活动工作表的单元格。将True / False输出到立即窗口。

使用与我的Excel答案相同的逻辑来查找相同位数的Cyclops数（如果有偶数，则短1位数！），然后将其与输入进行比较。

通过将它们减少到窗体节省计算水蚤数字时一些字节y = 2x^2 - x - 1（其中x = n-1为第n个水蚤数量，或者x = 2^Int(Log([A1])/Log(4))找到一个较少人或相等数量的比特的最大数目水蚤）和存储中的x的可变

（-5个字节，感谢Taylor Scott！）

PHP，74字节

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

在线尝试！

完全天真的非数学方法，只是字符串。

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

要么 基于上述 @Chronocidal算法的60字节。

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

在线尝试！

Haskell，82个字节

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

还有xnor的Python解决方案的端口：

Haskell，47个字节

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