如果您用无前导零的二进制形式表示某个正整数，并1用a 替换每个，(并0用a 替换每个)括号，那么所有括号会匹配吗？

在大多数情况下，它们不会。例如，9 1001以二进制形式出现，变成())(，其中仅前两个括号匹配。

但有时它们会匹配。例如，44为101100二进制，变成()(())，其中所有左括号都有匹配的右括号。

编写一个程序或函数，该程序或函数的正十进制整数为正，如果数字的双括号版本具有所有匹配的括号，则打印或返回真实值。如果不是，请打印或返回伪造的值。

以字节为单位的最短代码获胜。

相关的OEIS序列。

低于100的真实示例：

2, 10, 12, 42, 44, 50, 52, 56

低于100的虚假示例：

1, 3, 4, 5, 6, 7, 8, 9, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 43, 45, 46, 47, 48, 49, 51, 53, 54, 55, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99

TeaScript，9 个字节 16 18 20 22 24

@ETHproductions节省了2个字节

!x÷W(n,¢)

哇。太短了 使用@xnor的方法。这将使用递归替换函数（W），它将全部替换为10等于()。如果字符串为空白，则表示平衡。

使用发布此挑战后制作的TeaScript版本，可能会变成7个字节：

!x÷W(n)

不打高尔夫球

!xT(2)W(n,``)

说明

!      // NOT, returns true if empty string, else false
 xT(2)   // To binary
 W(n,``) // n is 10, reclusive replaces 10 or (), with nothing.

Pyth，10个字节

!uscG`T.BQ

在Pyth编译器中尝试此测试套件。

怎么运行的

              (implicit) Store the evaluated input in Q.
       .BQ    Return the binary string representation of Q.
 u            Reduce w/base case; set G to .BQ and begin a loop:
     `T         Return str(10) = "10".
   cG           Split G (looping variable) at occurrences of "10".
  s             Join the pieces without separators.
              Set G to the returned string.
              If the value of G changed, repeat the loop.
              This will eventually result in either an empty string or a
              non-empty string without occurrences of "10".
!             Return (and print) the logical NOT of the resulting string.

Python2，87个字节

try:exec"print 1,"+"".join(["],","["][int(c)]for c in bin(input())[2:])
except:print 0

滥用语法错误的可怕实现。

JavaScript（ES6），55 54 51字节

n=>![...n.toString(d=2)].some(c=>(d+=c*2-1)<2)*d==2

由于@Vɪʜᴀɴ和@xsot节省了字节！

说明

n=>
  ![...n.toString(    // convert the input to an array of binary digits
    d=2)]             // d = current depth (+2)
      .some(c=>       // iterate through the digits
        (d+=c*2-1)    // increment or decrement the parenthesis depth
          <2          // if the depth goes negative, return false
      )*
        d==2          // if we finished at a depth of 0, return true

Python 2，45个字节

f=lambda n,i=1:i*n>0<f(n/2,i+(-1)**n)or n<i<2

递归函数。n从末尾读取二进制数字，保留i对当前嵌套状态的计数。如果跌至低于0，则拒绝。当我们到达起点时，检查计数是否为0。

实际上，我们从开始计数，i=1以便于检查它是否已降至0。唯一的终端成功案例是n==0和i==1，并通过进行检查n<i<2。如果n==0或i降至0，我们会强制执行此检查，在这种情况下，它将自动失败。

feersum通过重组具有短路不等式的非递归情况节省了两个字节。

CJam，11个字节

ri2b"}{"f=~

这有点不干净：对于可括号的数字，它将打印一个或多个块。对于不可识别的数字，如果不打印任何内容到STDOUT，它将崩溃。如果您在CJam解释器中在线尝试此操作，请记住，它不能区分STDOUT和STDERR。

由于在CJam中非空/空字符串是真/假，并且打印输出始终是字符串，因此可以说它符合规则。以额外的3个字节为代价，总共14个字节，我们实际上可以在要打印的堆栈上留下一个true或falsy 字符串：

Lri2b"}{"f=~]s

对于不可识别的数字，这仍然会崩溃，默认情况下是允许的。

试运行

$ cjam <(echo 'ri2b"}{"f=~') <<< 52 2>&-; echo
{{}{}}
$ cjam <(echo 'ri2b"}{"f=~') <<< 53 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 54 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 55 2>&-; echo

$ cjam <(echo 'ri2b"}{"f=~') <<< 56 2>&-; echo
{{{}}}

怎么运行的

ri          e# Read an integer from STDIN.
  2b        e# Push the array of its binary digits.
    "}{"f=  e# Replace 0's with }'s and 1's with {'s.
          ~ e# Evaluate the resulting string.
            e# If the brackets match, this pushes one or more blocks.
            e# If the brackets do not match, the interpreter crashes.

CJam，15个字节

ri2bs_,{As/s}*!

在CJam解释器中尝试这种小提琴或立即验证所有测试用例。

怎么运行的

ri               Read an integer from STDIN.
  2b             Push the array of its binary digits.
    s            Cast to string.
     _,          Push the string's length.
       {    }*   Do that many times:
        As/        Split at occurrences of "10".
           s       Cast to string to flatten the array of strings.
              !  Push the logical NOT of the result.

Python，51个字节

lambda n:eval("'0b'==bin(n)"+".replace('10','')"*n)

匿名函数。计算为看起来像的表达式

'0b'==bin(n).replace('10','').replace('10','').replace('10','')...

每次替换都删除所有10与相对应的()。完成所有替换后，该函数返回是否剩下的只是二进制前缀0b。n因为一个k数字最多需要k/2步数，并且它的值最大，所以足以进行替换2**k。

Ruby，40岁

->i{n='%0b'%i;1while n.slice!'10';n<?0}

简单的字符串操作。降低'10'直到没有剩余。

认真地，17个字节

,;2@¡@`""9u$(Æ`nY

输出0为false和1true。在线尝试。

说明：

,      get value from stdin
;      dupe top of stack
2@¡    pop a: push a string containing the binary representation of a (swapping to get order of operands correct)
@      swap top two elements to get original input back on top
`""9u$(Æ` define a function:
  ""     push empty string
  9u$    push "10" (push 9, add 1, stringify)
  (      rotate stack right by 1
  Æ      pop a,b,c: push a.replace(b,c) (replace all occurrences of "10" in the binary string with "")
n      pop f,a: call f a times
Y      pop a: push boolean negation of a (1 if a is falsey else 0)

Japt，23个字节

Japt是Ja vaScri pt的缩写。口译员

Us2 a e@+X?++P:P-- &&!P

这使我想起Japt与TeaScript相比还有多远。在接下来的几天中更新了解释器之后，我想添加“快捷”字符，例如Vɪʜᴀɴ。

怎么运行的

       // Implicit: U = input number, P = empty string
Us2 a  // Convert U to base 2, then split the digits into an array.
e@     // Assert that every item X in this array returns truthily to:
 +X?   //  If X = 1,
 ++P   //   ++P. ++(empty string) returns 1.
 :P--  //  Otherwise, P--. Returns false if P is now -1.
&&!P   // Return the final result && !P (true if P is 0; false otherwise).
       // Implicit: output final expression

挑战结束后不久，@Vɪʜᴀɴ（现在称为@Downgoat）帮助我实现了递归替换功能，就像W在TeaScript答案中一样。这意味着现在仅用5个字节即可完成此挑战：

!¢eAs  // Implicit: U = input integer, A = 10
 ¢     // Convert U to binary.
  eAs  // Recursively remove instances of A.toString().
!      // Return the logical NOT of the result (true only for the empty string).

在线测试！

Mathematica，49个字节

(#~IntegerDigits~2//.{x___,1,0,y___}:>{x,y})=={}&

八度，48字节

@(a)~((b=cumsum(2*dec2bin(a)-97))(end)|any(b<0))

C ++，104 94字节

#include<iostream>
int n,c;int main(){for(std::cin>>n;n&c>=0;n>>=1)c+=n&1?-1:1;std::cout<<!c;}

使用此编译器运行，必须在运行之前指定标准输入。

说明

• main以外的声明初始化为0。
• 读取十进制会隐式转换为二进制，因为这是一台计算机。
• 我们检查比特/括号从右到左，因为n>>=1。
• c+=n&1?-1:1保留开括号的数量)。
• n&c>=0 当仅保留前导0或括号关闭的次数超过打开次数时停止。

Haskell，49个 46字节

0#l=l==1
_#0=2<1
n#l=div n 2#(l+(-1)^n)
f=(#1)

用法示例：f 13-> False。

我正在l像许多其他答案一样跟踪嵌套级别。但是，“平衡”情况由表示1，因此“ )大于(”情况为0。

PS：l+(-1)^n在xnor的答案中发现了嵌套级别调整。

Python 2中，60 57 56 55 53 52个 50个 49字节

n=input()
i=1
while i*n:i+=1|n%-2;n/=2
print i==1

感谢xnor节省了两个字节，并感谢feersum使最终字节数达到了49个！

说明

输入数字n将从其最低有效位开始处理。i是跟踪0和1的数量的计数器。注意，它被初始化1为保存一个字节。n如果1的数量超过0的数量（i<=0），则循环将在达到0 之前中止。

为了使括号保持平衡，需要两个条件：

• 0和1的数量相等（即i==1）
• 在此过程中，1的数量永远不会超过0的数量（即，循环不会因此而提前中止n==0）。编辑：我意识到此条件不是必需的，i如果必须满足，n!=0那么前面的条件就足够了。

的JavaScript ES5，118个 87 85 82 77字节

我认为有趣的技术。多亏了@ETHproductions和@NotthatCharles，减少了很多

function p(x){x=x.toString(2);while(/10/.test(x))x=x.replace(10,"");return!x}

的JavaScript ES6，77 57 56 54个字节

-21个字节到ETHproductions。

x=>[...x=x.toString(2)].map(_=>x=x.replace(10,""))&&!x

D，209170字节

import std.stdio;import std.format;import std.conv;void main(char[][]a){string b=format("%b",to!int(a[1]));int i;foreach(c;b){i+=c=='1'?1:-1;if(i<0)break;}writeln(i==0);}

这完全可以实现预期的功能，而没有任何额外的好处。

C，67字节

n;main(i){for(scanf("%d",&n);n*i;n/=2)i+=1-n%2*2;putchar(48+!~-i);}

我的python提交几乎相当一部分。

Prolog，147个字节

b(N,[X|L]):-N>1,X is N mod 2,Y is N//2,b(Y,L).
b(N,[N]).
q([H|T],N):-N>=0,(H=0->X is N+1;X is N-1),q(T,X).
q([],N):-N=0.
p(X):-b(X,L),!,q(L,0).

怎么运行的

b(N,[X|L]):-N>1,X is N mod 2,Y is N//2,b(Y,L).
b(N,[N]).

将十进制数N转换为列表形式的二进制表示形式（反向）。含义：

b(42,[0,1,0,1,0,1]) is true

然后：

q([H|T],N):-N>=0,(H=0->X is N+1;X is N-1),q(T,X).
q([],N):-N=0.

如果头元素为0，则在列表[H | T]上递归N，否则递减N。
如果N在任何时候变为负数，或者如果N最终不为0，则返回false，否则返回true。

切入

p(X):-b(X,L),!,q(L,0).

是否可以防止回溯并找到b（N，[N]）

测试的非二进制解，
请在此处在线尝试
使用以下查询运行它：

p(42).

PowerShell，106字节

param($a)$b=[convert]::ToString($a,2);1..$b.Length|%{if($b[$_-1]%2){$c++}else{$c--}if($c-lt0){0;exit}};!$c

_{可以肯定的是，不会赢得任何最短的比赛。但是，至少它在击败Java吗？}

使用非常长的.NET调用[convert]::ToString($a,2)将我们的输入数字转换为代表二进制数字的字符串。然后，我们使用来遍历该字符串1..$b.length|%{..}。每个循环，如果我们的数字是一个1（用%2而不是-eq1保存几个字节来评估），我们增加计数器；否则，我们将其递减。如果我们达到负值，则意味着到目前为止还)不止(于此，因此我们输出0和exit。一旦经过循环，$c要么是要么是0number >0，所以我们将其取为逻辑而不是!，这将得到输出。

这有一个怪异的结果：0如果parens不匹配是因为我们有更多的)输出，而False如果parens不匹配是因为我们有更多的输出(。本质上在功能上等效的虚假陈述，很有趣。如果均等匹配，则输出True。

GNU Sed（具有eval扩展名），27

s/.*/dc -e2o&p/e
:
s/10//
t

Sed并没有真正定义“真假”的概念，因此在此我声明空字符串表示真假，而其他所有字符串都表示假。

如果这是不可接受的，那么我们可以执行以下操作：

GNU Sed（具有eval扩展名），44

s/.*/dc -e2o&p/e
:
s/10//
t
s/.\+/0/
s/^$/1/

这将为真输出1，否则输出0。

𝔼𝕊𝕄𝕚𝕟（ESMin），21个字符/ 43个字节

ô⟦ïßḂ]Ĉ⇀+$?⧺Ḁ:Ḁ‡)⅋!Ḁ)

Try it here (Firefox only).

请注意，这使用预定义为数字的变量（特别是2和0）。预定义的数字变量从0到256。

19个字符/ 40个字节，非竞争性

⟦ïßḂ]Ĉ⇀+$?⧺Ḁ:Ḁ‡)⅋!Ḁ

Try it here (Firefox only).

决定实现隐式输出...但是，仍支持以前的输出形式，因此您将获得多个输出选项！

Java，129131字节

boolean T(int i){int j=0,k=0;for(char[]a=Integer.toString(i,2).toCharArray();j<a.length&&k>=0;j++){k+=a[j]=='1'?1:-1;}return k==0;}

大概可以缩短。解释来了。感谢Geobits提供4个字节的折扣！

C ++，61字节

我认为当前的C ++答案是错误的：它为所有偶数返回真实值，例如4。免责声明：我无法使用上述编译器，所以我使用了g ++ 4.8.4。问题在于使用二进制AND运算符，而不是使用逻辑AND，当闭括号的数量超过开括号的数量时，逻辑AND用于较早中断。如果true将其表示为具有全真位模式的单词，则此方法可能有效。在我的系统上（可能还有其他大多数系统上true）等价于1; 只有一位是真的。而且，n/=2比短n>>=1。这是功能的改进版本：

int f(int n,int c=0){for(;c>=0&&n;n/=2)c+=n&1?-1:1;return c;}

𝔼𝕊𝕄𝕚𝕟（非常不竞争），6个字符/ 8个字节

!ïⓑĦⅩ

Try it here (Firefox only).

很长时间之后，我决定重新审视这一挑战。better变得好多了。

这是一个单独答案的原因是，这两个版本几乎完全不同。

说明

将输入转换为二进制，递归替换10的实例，然后检查result是否为空字符串。

C＃98字节

bool f(int m){int i=0;foreach(char s in Convert.ToString((m),2)){if(s=='1')i+=2;i--;}return i==0;}

开放任何建议。我喜欢这个挑战，即使它是旧的