给定一个数字，确定它是否为折叠数字。

折叠数是一个数字，如果您将其用二进制表示形式并将其“对折”成一半，那就是将数字的前半部分与后半部分的XNOR乘以XNOR乘以相反的数字得到的结果，您将得到零。

如果该数字的二进制位数为奇数，则其中间数字必须为1，并且在折叠时将被忽略。

由于这可能会使您感到困惑，因此我举一些例子：

178

178的二进制表示为

10110010

要折叠它，我们首先将其切成两半

1011 0010

我们下半年倒转

1011
0100

我们对这两个部分进行异或运算：

0000

这是零，所以这是一个折叠数。

1644年

1644的二进制表示为

11001101100

要折叠它，我们首先将其切成两半

11001 1 01100

中间位是1，因此我们将其丢弃。

11001 01100

我们下半年倒转

11001
00110

我们对这两个部分进行异或运算：

00000

这是零，所以这是一个折叠数。

4254

4254的二进制表示为

1000010011110

要折叠它，我们首先将其切成两半

100001 0 011110

中间位是0，因此这不是折叠数。

任务

您的任务是接受一个正数，如果该数字是可折叠的，则返回一个真值；如果不是，则返回虚假的值。这是代码高尔夫球，因此请尽量减少字节数。

测试用例

以下是前99个折叠数字：

[1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120, 142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370, 412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738, 796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206, 1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848, 1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470, 2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132, 3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752, 3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558]

果冻，9 字节

Bœs2µḢ^UȦ

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

这个怎么运作

Bœs2µḢ^UȦ  Main link. Argument: n

B          Binary; convert n to base 2.
 œs2       Evenly split 2; split the base 2 array into chunks of equal-ish length.
           For an odd amount of digits, the middle digit will form part of the
           first chunk.
    µ      Begin a new, monadic chain. Argument: [A, B] (first and second half)
     Ḣ     Head; remove and yield A.
       U   Upend; reverse the digits in [B].
      ^    Perform vectorized bitwise XOR of the results to both sides.
           If A is longer than B, the last digit will remain untouched.
           n is a folding number iff the result contains only 1's.
        Ȧ  Octave-style all; yield 1 iff the result does not contain a 0.

05AB1E，13 12字节

码：

bS2ä`R0¸«s^P

使用CP-1252编码。在线尝试！

说明：

首先，我们使用将数字转换为二进制b。1644年变为11001101100年。我们用将它分成两部分2ä。例如，11001101100将变为：

[1, 1, 0, 0, 1, 1]
[0, 1, 1, 0, 0]

如果位数不均匀，则第一部分将收到额外的位数。我们R忽略最后一个字符串，并使用附加零0¸«。原因是仅在中间位为1（1 XOR 0 = 1和0 XOR 0 = 0）时给出真实的结果。如果没有中间位，则05AB1E只会忽略最后一位（附加的零）：

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0]

我们需要做的最后一件事是对元素进行异或运算并取结果的乘积。如果一个元素过多，则程序将忽略最后一个元素（[1, 0, 0] XOR [0, 1] = [1, 1]），例如：

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0] XOR

成为：

[1, 1, 1, 1, 1, 1]

乘积是1，这是事实。

Java 7中，152个145 142 138 134字节

boolean f(Long a){byte[]b=a.toString(a,2).getBytes();int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;for(;i<l/2;)z*=b[i]-b[l-++i];return z!=0;}

像回文一样在字符串上循环，寻找零。通过反复相乘来跟踪，因此您要做的就是检查最后是否不为零。

没有滚动条：

boolean f(Long a){
    byte[]b=a.toString(a,2).getBytes();
    int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;
    for(;i<l/2;)
        z*=b[i]-b[l-++i];
    return z!=0;
}

JavaScript（ES6），61 57 52字节

递归计算：

(bit(N) XOR bit(0)) AND (bit(N-1) XOR bit(1)) AND (bit(N-2) XOR bit(2)) etc.

其中N输入中设置的最高位的等级。

如果输入的位数为奇数，则将中间位与未定义（在pop()空数组上返回的值）进行异或，使其保持不变。因此，0中间一位清除输出，1中间一位不会改变其他运算的结果-这与折叠数的质询定义一致。

f=(n,[a,...b]=n.toString(2))=>a?(a^b.pop())&f(n,b):1

// testing integers in [1 .. 99]
for(var i = 1; i < 100; i++) {
  f(i) && console.log(i);
}

Python 2，57字节

s=bin(input())[2:]
while''<s!='1':s[-1]==s[0]<_;s=s[1:-1]

通过退出代码输出：Falsey错误，Truthy错误。

将输入转换为二进制。检查第一个和最后一个字符是否不相等，删除这些字符后保留并重复此操作。

s[-1]==s[0]<_如果第一个字符和最后一个字符不相等，则通过尝试评估名为的未分配变量，比较会产生错误_。如果它们相等，则不等式链会短路。当我们到达的中间元素时1，while循环终止，以特殊方式将其确定为OK。

我怀疑纯粹的算术方法会更短一些，例如递归，例如f=lambda n,r=0:...f(n/2,2*r+~n%2)...从翻转和反转的末端切掉二进制数字，并检测何时n和r等于中心1。尽管前导零和中心有一些微妙之处。

Python 2，94 79 72 67字节

F=lambda s:s in'1'or(s[0]!=s[-1])*F(s[1:-1])
lambda n:F(bin(n)[2:])

@xnor节省了12个字节

在第二行定义一个未命名的函数。

说明（添加了一些空格）：

F = lambda s:                                        # We define a function, F, which takes one argument, the string s, which returns the following:
             s in'1'                                 # Gives true if s is '' or s is '1', the first case is a base case and the second is for the middle bit case.
                     or(s[0] != s[-1])               # Or the first and last are different
                                      * F(s[1:-1])   # And check if s, without the first and last element is also foldable.
lambda n: F(bin(n)[:-2])                             # The main function, which calls F with the argument in binary form.

在这里尝试！

Haskell，89 88 86字节

f n|n<2=[n]|1>0=mod n 2:f(div n 2)
g n=elem(product$zipWith(+)(f n)$reverse$f n)[1,2]

通过按位求和反向的位表示并取乘积来工作。如果是1或2，则该数字为折叠数（如果折叠的偶数位为1，如果为奇数位则为2，中间为1）。

Python 2中，100 99 95 94字节

这感觉有点长，但是我会继续努力:) 1如果数字可以折叠，0则打印a ，否则。

a=bin(input())[2:]
b=len(a)
print(a[b/2]>=`b%2`)*all(c!=d for c,d in zip(a[:b/2],a[:~b/2:-1]))

^{在这里测试！}

^{感谢Wheat Wizard为1字节保存提供了:)}

^{感谢Rod节省了5个字节！:)}

> <>，37 + 3 = 40字节

<,2-@:%2:v!?:
=2lrv?=1l<+={$r0?
0=n;>

程序启动时，预期输入将出现在堆栈上，因此该-v标志为+3字节。

在线尝试！

果冻，13 个字节

Bœs2U0¦z0^/€Ạ

TryItOnline
或匹配术语最多4558

怎么样？

Bœs2U0¦z0^/€Ạ - Main link: n
B             - binary
 œs2          - split into 2 slices (odd length will have first longer than second)
     0¦       - apply to index 0 (the right hand one)
    U         - reverse
       z0     - zip together with filler 0 (thus central 1 or 0 will pair with 0)
          /€  - reduce with for each
         ^    -     XOR
            Ạ - All truthy?

Perl，46个字节

包括+1的 -p

在STDIN上使用数字运行

folding.pl <<< 178

folding.pl：

#!/usr/bin/perl -p
$_=($_=sprintf"%b",$_)<s%.%!/\G1$/^$&^chop%eg

我认为这甚至是一个perl错误。修改后，内部$_不应该获取匹配位置更新。在此程序中，匹配位置实际上超出了$_

Brachylog，16个字节

ḃḍ{↔|h1&b↔}ᵗz₂≠ᵐ

它在网上不太有效...

通过输入变量获取输入，通过成功或失败获取输出。z₂自4月30日起，它就一直依赖该语言，但是我们忘记要求将它拉到TIO上了，因此暂时只适用于该语言的本地安装。无论哪种方式，这可能都是一种过于幼稚的方法。

                    The input
ḃ                   's binary representation
 ḍ                  split in half
  {       }ᵗ        with its second half
   ↔|               either reversed, or
     h1             if it starts with 1
       &b           relieved of its first element
         ↔          and then reversed
              ≠     has no duplicate elements
            z  ᵐ    in any pair of elements zipped from the two halves
             ₂      which are equal in length.

Brachylog（在TIO上），19个字节

ḃḍ{↔|h1&b↔}ᵗlᵛ↖Lz≠ᵐ

在线尝试！

lᵛ↖Lz在功能上等效于z₂（如果您在其他任何地方都不使用变量L），但它也长了三个字节。

Python 2，76 71 69字节

感谢@Dennis提供-5个字节（''位于中'1'，因此请替换in('','1')为in'1'）
感谢@xnor 提供-2个字节（使用乘法(...)*代替and）

f=lambda n:f(bin(n)[2:])if n<''else n in'1'or(n[0]!=n[-1])*f(n[1:-1])

伊迪奥

递归函数，在第一次调用时n是一个数字，因此使用时，其求值小于空字符串if n<''，并且再次调用该函数，但n将其转换为二进制字符串；尾部为空字符串（偶数位长度）或中间位，如果为null或a，则返回true '1'；在下降的过程中，它测试外部位是否不相等（等于XOR），然后递归内部位n[1:-1]。

Python 2，63个字节

s=bin(input())[2:]
while s[0]!=s[-1]:s=s[1:-1]or'1'
print'1'==s

打印True或False。s只要第一个和最后一个字符不相等，就采用二进制表示形式并重复删除它们。检查剩下的是空字符串还是中央字符串1。这可以通过转换''为'1'并检查结果是否等于来完成'1'，这还可以避免在空字符串上出现索引错误。

PowerShell v2 +，143字节

两种可能的方法，都使用相同的字节数。

方法1：

param($n)if($n-eq1){$n++}$o=1;0..(($b=($n=[convert]::ToString($n,2)).length-1)/2-!($b%2))|%{$o*=$n[$_]-ne$n[$b-$_]};$o*(+"$($n[$b/2])",1)[$b%2]

接受输入$n，如果对输入是-eq对的1（此算法的特殊情况），则将其递增。将utput 设置$o为1（即假设为真），然后从ed到0已[convert]编辑为二进制的输入数字的中点循环。注意-!($b%2)要考虑奇数长度的二进制数。

每次迭代时，我们将当前数字$n[$_]与从末尾开始的相同长度的数字进行比较$n[$b-$_]，然后将布尔结果相乘$o（基本上-and对所有数字执行一次）。循环完成后，我们可能需要考虑中间的二进制数字，即末尾的伪三元数字（通过索引的数组$b%2）。那1还是0留在管道和输出是隐含的。

方法2：

param($n)for($n=[convert]::ToString($n,2);$n.Length-gt2){if($n[0]-ne$n[-1]){$n=$n[1..($n.Length-2)]}else{0;exit}}($n-join'+'|iex)-eq1-or$n-eq10

接受输入并对[convert]二进制数进行相同的处理。然后我们就处于for循环中，只要.length二进制字符串的-g成为than 2。当我们在循环，如果第一个$n[0]和最后一个$n[-1]数字是-nOT eQUAL，片这两个数字断$n，并重新进入店内$n。否则，输出0和exit。一旦我们循环出门在外，我们要么有（数组1，1,0，0,1，1,1，或0,0），或两个二进制串10，或3 11。因此，我们需要测试这两种可能性。首先，我们-join $n与一起+评估结果并测试其结果1（这是阵列真1，1,0和0,1，但是$false对于阵列0,0和1,1或字符串10或11）。的另一半-or是测试是否$n是-eqUAL到10（即，输入的2）。该布尔值保留在管道上，并且输出是隐式的。

CJam，13个字节

ri2b_W%.+:*3&

在线尝试！或生成不超过给定数字的折叠数字列表。

ri2b   e# convert input to binary
_W%.+  e# flip and sum (if folding all bits are 1 except middle)
:*     e# product is 0 or power of 2 (2 if middle folds)
3&     e# keep only 1 or 2, everything else becomes 0 (false)

MATL，16字节

tBn2/kW&\hBZ}P=~

Truthy是一个包含所有对象的数组。在此处检查真假标准。

在线尝试！或验证前20个测试用例。

说明

让我们以输入1644为例。

t     % Imolicitly take input. Duplicate
      %   STACK: 1644, 1644
Bn    % Number of digits of binary expansion
      %   STACK: 1644, 11
2/k   % Divide by 2 and round down
      %   STACK: 1644, 5
W     % 2 raised to that
      %   STACK: 1644, 32
&\    % Divmod
      %   STACK: 12, 51
h     % Concatenate horizontally
      %   STACK: [12 51]
B     % Binary expansion. Each numnber gives a row, left-padded with zeros if needed
      %   STACK: [0 0 1 1 0 0; 1 1 0 0 1 1]
Z}    % Split into rows
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
P     % Reverse
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
=~    % True for entries that have different elements
      %   STACK: [1 1 1 1 1 1]
      % Implicitly display

PHP，101字节

for($r=1;$i<($l=strlen($b=decbin($argv[1])))>>1;)$r*=$b[$i]^1^$b[$l-++$i]^1;$r*=$l%2?$b[$i]:1;echo$r;

或带日志

for($r=1,$s=log($n=$argv[1],2)^0;2*$i<$s;)$r*=($n>>$i)%2^($n>>$s-$i++)%2;$s%2?:$r*=($n>>$i)%2;echo$r;

带数组的108个字节

for($r=1,$a=str_split(decbin($argv[1]));$a;)$r*=array_pop($a)!=($a?array_shift($a):0);$r*=$a?$a[0]:1;echo$r;

真实值<10000

1,2,6,10,12,22,28,38,42,52,56,78,90,108,120,142,150,170,178,204,212,232,240,286,310,346,370,412,436,472,496,542,558,598,614,666,682,722,738,796,812,852,868,920,936,976,992,1086,1134,1206,1254,1338,1386,1458,1506,1596,1644,1716,1764,1848,1896,1968,2016,2110,2142,2222,2254,2358,2390,2470,2502,2618,2650,2730,2762,2866,2898,2978,3010,3132,3164,3244,3276,3380,3412,3492,3524,3640,3672,3752,3784,3888,3920,4000,4032,4222,4318,4462,4558,4726,4822,4966,5062,5242,5338,5482,5578,5746,5842,5986,6082,6268,6364,6508,6604,6772,6868,7012,7108,7288,7384,7528,7624,7792,7888,8032,8128,8318,8382,8542,8606,8814,8878,9038,9102,9334,9398,9558,9622,9830,9894

朱莉娅 66字节

c(s)=s==""||s=="1"||(s[1]!=s[end]&&c(s[2:end-1]))
f(x)=c(bin(x))

我的第一个高尔夫！的工作方式与长度相同的Python解决方案相同，但由于语言而略有差异（不过我确实自己提出了...）。

说明：

c(s) = s == "" || # Base case, we compared all the digits from 
                  # both halves.
       s == "1" || # We compared everything but left a 1 in the middle
       (s[1] != s[end] &&  # First digit neq last digit (XNOR gives 0).
        c(s[2:end-1]))     # AND the XNOR condition is satisfied for the  
                           # 2nd to 2nd to last digit substring.
f(x) = c(bin(x))  # Instead of a string f takes an integer now.

C，223 201 189 194 178个字节

i,j,m,l,r;f(n){for(m=j=1,i=n;i/=2;++j);for(l=r=i=0;i<j/2;i++)r|=n&m?1<<j/2-i-1:0,m*=2;i=(j&1&&n&m)?i+1:(j&1)?l=r:i;n>>=i;for(m=1;i<j;i++)l|=n&m,m*=2;return !(~(l^r)&(1<<j/2)-1);}

蛮力算法。让我们看看它可以打多远。

更好的测试设置错误修正...

 main()
 {
    int t, s, u, testSet[] = 
    {
    1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120,
    142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370,
    412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738,
    796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206,
    1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848,
    1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470,
    2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132,
    3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752,
    3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558
    };


    for (u=s=0,t=1;t<=4558;t++)
    {
        if (f(t))
        {
          u++;            
          if (testSet[s++]!=t)
              printf("BAD VALUE %d %d\n", testSet[s-1], t);
        }
    }

    printf("%d == %d Success\n", u,
           sizeof(testSet)/sizeof(testSet[0]));

}

MATL，13字节

BttP=<~5Ms2<*

Truthy是一个包含所有对象的数组。在此处检查真假标准。

在线尝试！或验证前20个测试用例。

说明

以输入1644为例：

B     % Implicit input. Convert to binary
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0]
t     % Duplicate
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [1 1 0 0 1 1 0 1 1 0 0]
tP=   % Element-wise compare each entry with that of the reversed array
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [0 0 0 0 0 1 0 0 0 0 0]
<~    % True (1) if matching entries are equal or greater
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
5M    % Push array of equality comparisons again
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], [0 0 0 0 0 1 0 0 0 0 0]
s     % Sum of array
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
2<    % True (1) if less than 2
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
*     % Multiply
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
      % Implicitly display

JavaScript，71个字节

(i,n=i.toString(2))=>/^(1*)2?\1$/.test(+n+ +n.split``.reverse().join``)

定义一个匿名函数。

此方法可能不是最短的，但据我所知，它是唯一的。它将二进制数加到反转的自身上，将它们视为十进制，然后使用正则表达式检查结果是否有效。

视网膜，92字节

字节数假定为ISO 8859-1编码。

.+
$*
+`(1+)\1
${1}0
01
1
^((.)*?)1??((?<-2>.)*$.*)
$1¶$3
O$^`.(?=.*¶)

T`01`10`^.*
^(.*)¶\1

在线尝试

转换为一元。将其转换为二进制。将数字切成两半，1如果有则去掉中间的数字。颠倒前半部分。切换其一和零。如果两个相等，则匹配。

视网膜，71 70 60字节

.+
$*
+`^(1*)\1(1?)\b
$1 $.2
+`^ (.)(.*) (?!\1).$
$2
^( 1)?$

我可能仍然有很多关于Retina的知识（例如递归正则表达式？）。说明：步骤1从十进制转换为一元。步骤2从一元转换为伪二进制。只要不匹配，步骤3就会从两端删除数字。如果需要，第四步与可选的最终中心1相匹配。编辑：感谢@ mbomb007，保存了1个字节。通过改进我的一元到二进制转换节省了10个字节。

Python 2，61 59字节

节省两个字节用于将移位转换为乘法

m=n=input()
i=0
while m:i*=2;i+=m&1;m/=2
print(n+i+1)&(n+i)

返回0折叠号，返回非折叠号。使用位旋转方法。

C，65 63字节

两个字节用于将移位转换为乘法

i,m;
f(n){
 m=n;i=0;
 while(m)i*=2,i+=m&1,m/=2;
 return(n+i+1)&(n+i);
}

字节数中已经排除了空格，折叠数返回0，非折叠则返回其他任何值。使用位旋转方法。

k，77个字节

{X:2 0N#X@&:|\X:0b\:x;c:#:'X;$[(~*X 1)|(=). c;~|/(=).(::;|:)@'(-&/ c)#'X;0b]}

作为解释，翻译成 q

{X:2 0N#X where maxs X:0b vs x;
  c:count each X;
  $[(not first last X)or(=). c;
    not any(=).(::;reverse)@'(neg min c)#'X;0b]
  };