警告：这不是“嘿，让我们在ASCII艺术中画蛋糕”挑战！请继续阅读;）

前一段时间是我的生日，现在我33岁。

因此，这种尴尬的社会传统包括邀请家人和朋友，在蛋糕上放数字蜡烛，唱歌和礼物。

   33   
--------

我可以使用二进制系统来代替标准蜡烛，而不是数字：我将6根蜡烛放在蛋糕上，然后点燃2根蜡烛。

 100001
--------

我可以看到我这个年龄的十进制数和二进制数都是回文！

挑战

我想知道是否可以将其他任何数字放在装有蜡烛的蛋糕上，并且回文，十进制和二进制。

写一个程序/功能测试一个数是否在回文两者十进制和二进制。但是，等等，还有更多：在二进制中，测试的前导零计数！

输入值

一个十进制数x，我想测试，如果是生日回文0 <X <2 ³² -1（是的，人在我住的尺寸很长）

输出量

Truthy如果它恰好满足这两个条件，否则Falsey：

• 数字的十进制表示形式是标准回文
• 数字的二进制表示形式是标准回文，添加前导零可能对此有所帮助

测试用例

1 > 1 => Truthy
6 > 110 (0110) => Truthy
9 > 1001 => Truthy
10 > 1010 (01010) => Falsey, 10 is not palindromic
12 => 1100 (001100) => Falsey, 12 is not palindromic
13 => 1101 (...01101) => Falsey, neither 13 nor 1101 are palindromic
14 => 1110 (01110) => Falsey, 14 is not palindromic
33 > 100001 => Truthy
44 > 101100 (..0101100) => Falsey, 101100 is not palindromic
1342177280 > 1010000000000000000000000000000 (00000000000000000000000000001010000000000000000000000000000) => Falsey, 1342177280 is not palindromic (but the binary representation is)
297515792 > 10001101110111011101100010000 (000010001101110111011101100010000) => Truthy

规则

• 不允许出现标准漏洞
• 允许内置库转换和测试
• 这是代码高尔夫球，最短的代码获胜！

祝你好运，生日快乐！

05AB1E，7个字节

b0Ü‚DíQ

在线尝试！ 或作为测试套件

说明

b         # convert input to binary
 0Ü       # remove trailing zeroes
   ‚      # pair with input
    D     # duplicate
     í    # reverse each (in the copy)
      Q   # check for equality

Python 3，59个字节

lambda a:all(c==c[::-1]for c in[str(a),bin(a).strip('0b')])

在线尝试！

-3字节归功于Rod
-3字节归功于Connor Johnston

JavaScript（ES6），65个字节

退货 0或1。

n=>(g=b=>[...s=n.toString(b)].reverse().join``==s)()&g(2,n/=n&-n)

怎么样？

辅助函数克（）取整数b作为输入，并测试是否Ñ是在碱回文b。如果未指定b，则仅在测试n之前将n转换为字符串。

我们得到的二进制表示摆脱尾随零的ñ通过隔离至少显著1与n&-n除以ñ通过所产生的数量。

有趣的事实：这是真实的，0因为(0/0).toString(2)equals "NaN"是回文。（但是0仍然不是有效的输入。）

测试用例

let f =

n=>(g=b=>[...s=n.toString(b)].reverse().join``==s)()&g(2,n/=n&-n)

console.log(f(1 )) // Truthy
console.log(f(6 )) // Truthy
console.log(f(9 )) // Truthy
console.log(f(10)) // Falsey
console.log(f(12)) // Falsey
console.log(f(13)) // Falsey
console.log(f(14)) // Falsey
console.log(f(33)) // Truthy
console.log(f(44)) // Falsey

Mathematica，52个 49字节

i=IntegerReverse;i@#==#&&!i[#,2,Range@#]~FreeQ~#&

在Wolfram Sandbox上尝试

用法

f = (i=IntegerReverse;i@#==#&&!i[#,2,Range@#]~FreeQ~#&);

f[6]

True

f /@ {9, 14, 33, 44}

{True, False, True, False}

说明

i=IntegerReverse;i@#==#&&!i[#,2,Range@#]~FreeQ~#&

i=IntegerReverse                                   (* Set i to the integer reversing function. *)
                 i@#==#                            (* Check whether the input reversed is equal to input. *)
                       &&                          (* Logical AND *)
                          i[#,2,Range@#]           (* Generate the binary-reversed versions of input, whose lengths *)
                                                   (* (in binary) are `{1..<input>}` *) 
                                                   (* trim or pad 0s to match length *)
                                        ~FreeQ~#   (* Check whether the result is free of the original input *)
                         !                         (* Logical NOT *)

内置版本 PalindromeQ

PalindromeQ@#&&!IntegerReverse[#,2,Range@#]~FreeQ~#&

Pyth-13个字节

&_I.s.BQ`Z_I`

测试套件。

Japt，14个字节

s ꬩ¢w n2 ¤ê¬

在线测试！

说明

 s ê¬ © ¢   w n2 ¤  ê¬
Us êq &&Us2 w n2 s2 êq   Ungolfed
                         Implicit: U = input integer
Us êq                    Convert U to a string and check if it's a palindrome.
        Us2 w            Convert U to binary and reverse. 
              n2 s2      Convert to a number, then back to binary, to remove extra 0s.
                    êq   Check if this is a palindrome.
      &&                 Return whether both of these conditions were met.

质子，57字节

a=>(b=c=>c==c[to by-1])(str(a))*b(bin(a)[2to].strip('0'))

在线尝试！

APL，27 31字节

∧/(⌽≡⊢)∘⍕¨{⍵,⊂{⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢⍵}

如何运作？使用6作为参数...

      2⊥⍣¯1⊢6 ⍝ get the bit representation
1 1 0

      ⌽2⊥⍣¯1⊢6 ⍝ reverse it (if it's a palindrome, it doesn't matter)
0 1 1

      {⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢6 ⍝ drop off the trailing (now leading 0's)
1 1

      6,⊂{⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢6 ⍝ enclose and concatenate the bits to the original number
┌─┬───┐
│6│1 1│
└─┴───┘

      (⌽≡⊢)∘⍕ ⍝ is a composition of
      ⍕ ⍝ convert to string and 
      (⌽≡⊢) ⍝ palindrome test

      (⌽≡⊢)∘⍕¨6,⊂{⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢6 ⍝ apply it to each of the original argument and the bit representation
  1 1

      ∧/(⌽≡⊢)∘⍕¨6,⊂{⍵/⍨∨\⍵}⌽2⊥⍣¯1⊢6  ⍝ ∧/ tests for all 1's (truth)
  1

在TryAPL.org上尝试

果冻，8字节

Bt0ŒḂaŒḂ

在线尝试！

Brachylog，7个字节

↔?ḃc↔.↔

在线尝试！

太多了↔...

说明

使用隐式输入和输出，代码为： ?↔?ḃc↔.↔.

?↔?        The Input is a palindrome
   ḃ       Convert it to the list of its digits in binary
    c      Concatenate it into an integer
     ↔     Reverse it: this causes to remove the trailing 0's
      .↔.  The resulting number is also a palindrome

APL（Dyalog Classic），26个字节

{≡∘⌽⍨⍕⍵,⍵,⍨(<\⊂⊢)⌽2⊥⍣¯1⊢⍵}

说明

                  2⊥⍣¯1⊢⍵  encode ⍵ as binary
                 ⌽         reverse
           (<\⊂⊢)          partition from first 1
      ⍵,⍵,⍨                prepend and append ⍵
    ⍕                     turn into text string
≡∘⌽⍨                       match text with its reverse (f⍨X is XfX, where f is a composed function that reverses its right argument and matches with left)

在线尝试！

Perl，53个+3（-pal）字节

$_=sprintf"%b",$_;s/0+$//;$_="$_/@F"eq reverse"@F/$_"

在线尝试

10 岁个字节

如果为true，则返回[1]；如果为false，则返回[0]

ĐɓƖ₫áĐ₫=ʁ∧

在线尝试！

说明：

              Implicit input
Đ             Duplicate input
ɓ             Get input in binary (as string)
Ɩ             Cast to integer
₫             Reverse the digits (this removes any trailing zeroes)
á             Push the stack into a list
Đ             Duplicate the list
₫             Reverse the digits of each element of the list
=             Are the two lists equal element-wise
ʁ∧            Reduce the list by bitwise AND

视网膜，72字节

.+
$*_;$&
+`(_+)\1
$+0
0_
_
0+;
;
+`\b(\w)((\w*)\1)?\b
$3
(\B;\B)|.*
$.1

在线尝试！链接包括测试用例。通过创建原始数字的一元副本来工作，但使用_s，以免被输入混淆11。一元数然后转换为“二进制”并去除尾随零。然后回文被连续截断，最后阶段测试是否还有剩余。

Mathematica，70个字节

(P=PalindromeQ)[PadRight[#~IntegerDigits~2,#~IntegerExponent~2]]&&P@#&

外壳，14个字节

¤&S=↔ȯ↓=0↔ḋ⁰d⁰

在线尝试！

取消高尔夫/解释

             d⁰  -- digits of input in decimal
          ḋ⁰)    -- digits of input in binary
         ↔       --   reverse
     (↓=0        --   and drop all leading zeros
¤&               -- test the two lists if
  S=↔            --   they're equal to their own reverse

盖亚 10字节

ṙṭ@ḍ2⁻Πbṭ∧

在线尝试！

说明

我不使用二进制的前导零进行检查，而是使用不带尾随零的检查。

ṙ           String representation of number
 ṭ          Is palindromic?
  @         Push input again
   ḍ        Prime factors
    2⁻      Remove all 2s
      Π     Product
       b    Convert to binary
        ṭ   Is palindromic?
         ∧  Logical and

C（gcc），105个字节

r(n,b){int s=0,c=n;for(;n;n/=b)s=s*b+n%b;return s==c;}
c;f(n){for(c=n;c%2<1;c/=2);return r(n,10)&r(c,2);}

在线尝试！

C＃（.NET Core），130129179 173 + 23个字节

几件事，感谢Ed Marty指出我需要检查前面是否有多个0来填充回文。而且我需要确保可以检查x ^ ³² -1。

x=>{var a=Convert.ToString(x,2);var b=x+"";Func<string,bool>p=z=>z.SequenceEqual(z.Reverse());return new int[a.Length].Select((_,z)=>p(new string('0',z)+a)).Any(z=>z)&p(b);}

在线尝试！

Python 2，56个字节

lambda n:all(s==s[::-1]for s in(`n`,bin(n).strip("0b")))

在线尝试！

使用Python的strip方法同时删除bin(..)输出的前导0b 和二进制数的尾随零（因为它们始终具有匹配的位）。

佩斯，25 22 19 18 17字节

- 通过进一步学习语言来获得3 6 7 8字节

Ks_.Bsz&_IzqKs_`K

说明：

Ks        Set K to the integer version of...
 _.BsJ    Reverse string of the binary input
&         And
 _Iz      Is the input equal to the reverse of itself?
 qKs_`K   Is K equal to int(the reverse of basically string(K))

我确信这可以解决，我会继续努力。

测试套件

PHP，69 + 1字节

$q=trim(decbin($p=$argn),0);if(strrev($p)==$p&&strrev($q)==$q)echo$p;

与管道一起运行 -nR
回显原始输入，以表示真假，无输入则表示假。

在线尝试！

八度，68 66字节

@(x)all([d=num2str(x) b=deblank(['' dec2bin(x)-48])]==flip([b d]))

在线尝试！

Octave的初始产品。

我们基本上创建了一个数组，该数组包含数字作为十进制字符串和数字作为二进制字符串，并删除了结尾的0。然后，我们创建一个与字符串相同，但二进制和十进制数字被翻转的数组。最后，将两个数组进行比较，如果匹配则返回真（两个回文），否则返回假（一个或两个都不回文）。

• 使用flip代替保存2个字节fliplr。

APL2（非Dyalog），36字节

(N≡⌽N←⍕N)^∨/(((⌽B)⍳1)↓B)⍷B←(32⍴2)⊤N←

首先让B为N的32位表示形式：

B←(32⍴2)⊤N

然后镜像B并找到第一个1的位置：

(⌽B)⍳1

然后从B删除那么多位置。这将保留正确的前导0数。

然后执行FIND和OR-REDUCTION以查看裁剪后的B是否包含其自己的镜像。

现在让我们看一下N（十进制）。最左括号的表达式将N转换为字符向量，并检查它是否匹配自己的镜像。

最后，一个AND将两个检查加在一起。

在APL2中，我无法制作整齐的lambda，所以我写了一个单线并包含分配箭头。希望这不会作弊。

爪哇8，105个 104字节

n->{String t=n+n.toString(n,2).replaceAll("0*$","")+n;return t.contains(new StringBuffer(t).reverse());}

说明：

在这里尝试。

n->{                         // Method with Integer parameter and boolean return-type
  String t=n                 //  Create a String `t` starting with the input Integer
    +n.toString(n,2)         //  Append the binary representation of the input Integer,
      .replaceAll("0*$","")  //   with all trailing zeroes removed
    +n;                      //  Append the input Integer again
  return t.contains(new StringBuffer(t).reverse());
                             //  Return true if `t` is a palindrome
}                            // End of method