让我们有一个函数，它接收一个字符串并删除所有成对的相邻相同字符。例如$f$

$f(a\color{red}{bb}ba\color{red}{cc}) = aba$

请注意，当两对重叠时，我们只会移除其中一对。

如果重复应用最终产生空字符串，我们将调用完美配对的字符串。例如，上面的字符串不是完美配对的，因为如果再次应用，我们仍然会得到。然而，像这样的字符串是完美配对的，因为如果我们应用三次，我们将得到空字符串$abbbacc$$f$$aba$$eabbccadde$$f$

$f(ea\color{red}{bbcc}a\color{red}{dd}e) = eaae$

$f(e\color{red}{aa}e) = ee$

$f(\color{red}{ee}) =$

您的任务是编写完美配对的计算机代码，该代码采用一个字符串（可打印ASCII），并确定其是否完全配对。源的字节串本身必须是完美配对的字符串，尽管您的代码不必一定限于可打印的ASCII。

您可以输出两个不同的值：一个用于输入完美配对的情况，另一个用于不配对的情况。

这是一个代码问题，因此答案将按其来源的字节大小进行评分，而字节越少越好。

测试用例

$abbbacc \rightarrow \mathrm{False}\\ abcba \rightarrow \mathrm{False}\\ abab \rightarrow \mathrm{False}\\ abbbaabacc \rightarrow \mathrm{True}\\ eabbccadde \rightarrow \mathrm{True}\\ bbbb \rightarrow \mathrm{True}$

Haskell，146 124字节

((""##))
a===bb=bb==a
((aa:bb))##((cc:dd))|aa===cc=bb##dd|1==1=((cc:aa:bb))##dd
a##""=""===a
""##cc=((cc!!00:cc!!00:""))##cc

没意见。返回True或False。

在线尝试！

编辑：-22字节感谢@Cat向导

Python 2，94个字节

ss=''

for cc in input():ss=[cc+ss,ss[1:]][cc==ss[:1]]

print''==ss##tnirp[,+[=:)(tupni nirof=

在线尝试！

整个更新步骤ss=[cc+ss,ss[1:]][cc==ss[:1]]取消为=[+,[。

05AB1E，26 24 22 20 18字节

-2个字节，感谢ovs。如果字符串完全配对，则输出0，否则输出1。

ΔγʒgÉ}JJ}ĀqqĀÉgʒγΔ

在线尝试！

ΔγʒgÉ} JJ}ĀqqĀÉgʒγΔ–完整程序。
Δ} –直到结果不再改变：
 γʒ} –将字符串分割成相等字符的块，然后通过以下方式过滤：
   gÉ–长度是否奇怪？
      JJ –过滤后，将零件重新结合在一起，但是要这样做
                     与以前的版本一样，两次以保存2个字节。
         Ā–检查结果是否为空
          q –终止（退出）执行。其余代码将被忽略。
           qĀÉgʒγΔ–镜像不匹配的部分以帮助进行源布局。

之前的版本

这个纯粹依靠未定义的行为（因此没有“死代码”），对于完全配对的字符串，输出[['0']]；对于完全不匹配的字符串，输出[['1']]：

ΔγεDgÉ£}JJ}ĀĀ£ÉgDεγΔ 

并说明了22字节的版本，这只是上面的版本，但不滥用UB，并产生合理的值。

ΔγεDgÉ£}JJ}ĀqqĀ£ÉgDεγΔ – Full program.
Δ         }            – Until fixed point is reached (starting from the input value):
 γε    }                 – Group equal adjacent values, and for each chunk,
   DgÉ                     – Duplicate, get its length mod by 2.
      £                    – And get the first ^ characters of it. This yields the
                             first char of the chunk or "" respectively for odd-length
                             and even-length chunks respectively.
         JJ                – Join the result to a string, but do this twice to help
                             us with the source layout, saving 2 bytes.
            Ā           – Check if the result is an empty string.
             q          – Terminate the execution. Any other commands are ignored.
              qĀ£ÉgDεγΔ – Mirror the part of the program that isn't otherwise removed
                          anyways. This part forgoes }JJ} because that substring will
                          always be trimmed by the algorithm anyway.

Cubix，54个字节

U#;!u1@.Oi>??>i..??O.@1^^...u--u.u!ww;..#..U..;..;!^^!

如果字符串完美配对，则不输出任何内容1。
在这里尝试

集中化

      U # ;
      ! u 1
      @ . O
i > ? ? > i . . ? ? O .
@ 1 ^ ^ . . . u - - u .
u ! w w ; . . # . . U .
      . ; .
      . ; !
      ^ ^ !

说明

大多数字符都是完美配对代码所需的填充符。用.（无操作）替换那些，我们得到

      U # ;
      ! u 1
      @ . O
i . ? . > i . . ? . . .
. . ^ . . . . u - . . .
. . . w ; . . . . . . .
      . ; .
      . ; !
      ^ ^ !

这可以分为三个步骤：

• 检查空字符串（左侧i和?）。
• 循环播放，将字符扔到堆栈上并弹出重复项（所有内容都在底部和右侧）。
• 检查堆栈是否为空（顶部的东西）。

V，20，18个字节

òóˆ±òø‚

::‚øò±ˆóò

在线尝试！

十六进制转储：

00000000: f2f3 88b1 f2f8 820a 0a3a 3a82 f8f2 b188  .........::.....
00000010: f3f2                                     ..                   ....

输出0表示真实，1表示虚假。感谢nmjcman101间接节省2个字节。

ò        ò        " Recursively...
 ó                "   Remove...
  <0x88>          "     Any printable ASCII character
        ±         "     Followed by itself
          ø       " Count...
           <0x82> "   The number of non-empty strings

::<0x82>øò±<0x88>óò      " NOP to ensure that the code is paired

R，142126字节

严格的逻辑和@Giuseppe打高尔夫球的一些注释字节

f=function(x,p="(.)\\1")"if"(grepl(p,x),f(sub(p,"",x)),!nchar(x))##x(rahcn!,x,,p(bus(f,)x,p(lperg("fi")"1\\).("=p,x(noitcnuf=f

在线尝试！

f=function(x,p="(.)\\1")"if"(nchar(x),"if"(grepl(p,x),f(sub(p,"",x)),0),1)##)1,)0,xp(bus(f,)x,p(lperg("fi",)x(rahcn("fi")"1).("=p,x(noitcnuf=f

原版的：

在线尝试！

递归检测器函数，然后以相反的顺序注释函数中的所有字符。

APL（Dyalog），38字节

''≡{'(.)\1'⎕R''⊢⍵}⍣≡⍝⍝≡⍣}⍵⊢R⎕'1\).('{≡

在线尝试！

视网膜，28 26字节

+`(.)\1

C`^$

$^`C1\).(`+

在线尝试！

虚假案件`C1\).(`+0`C1\).(`+和`C1\).(`+1`C1\).(`+真实案件的输出。

Brain-Flak，228200字节

(()){{{}([]<<{{(({}<<>>)<<>>[({})]){{{{}(<<<<>>()>>)((<<>>))}}}{}{}<<>>{}<<>>}}{}<<>>>>[[]])}}{}(<<({{(())(<<()>>)}}<<>>)>>){{{{}{}}((){{}{}{}{}{}}(()())())[[]((){{}{}}())[]]((){{}{}}[[][]]()){{}{}}}}

在线尝试！

这有点概念证明。它可能会更短。但是，它不使用任何注释。

0,0输入是否完美配对时输出，如果输入没有完美配对，0,1则输出。

sed 4.2.2，34个字节

:;:t;ss((..??\??))\1ss1;t;/..??/cc

在线尝试！

配对的字符串给出空输出，未配对的字符串给出 ct:

平凡的回文版本为32 :;ss(.)\1ss;t;/./cc/./;t;1\).(;:。旧的解决方案是:;ss((..??\??))\1ss1;t;;/./cc/./t:（已更改，因为当前的滥用c较少，编辑：是的，现在c：D 之后只有1个字符）

（请注意，这;是语句分隔符）

: 声明一个空标签

:t 声明标签 t

ss((..??\??))\1ss1是替换项，在sed中，您可以将定界符更改为替换项，这是我通过将其更改为来完成的s，因此此操作是替换第一个（如1末尾的所示）

• 的比赛 ((..??\??))\1

  • . 任何字符
  • .?? 后跟一个可选的可选字符
  • \?? 和一个可选的 ?
  • 跟在它旁边的是同一件事

• 一无所有

现在此替换已与自身配对，因此;它之前和之后的s也都被取消了

t 然后循环回到标签，直到没有其他成功的替换

/..?/如果.（通配符）后接.?可选字符

• cc 将缓冲区更改为 c

脑高射炮，112 110 108个字节

(()){{}({<<(({}<<>>)<<>>[({})]){{((<<>>)<<>>)}}{}{##{

}<<>>>>{}<<>>}<<>>)}{}((){{<<>>[[]]}})##}{}])}{([)}(}

在线尝试！

这是基于我的回答，方括号是否匹配？。

尝试不使用评论，但在尝试使流行nilads（{}）配对时陷入困境。问题在于配对一对支架的最简单方法是将其包围在另一对相同的支架中。尽管这对其他尼拉德人来说很容易，但{...}monad会创建循环。为了退出循环，您必须按下0，但是一旦退出循环，则必须弹出0，这使问题更加复杂。

66字节预配对的解决方案是：

(()){{}({<(({}<>)<>[({})]){((<>)<>)}{}{}<>>{}<>}<>)}{}((){<>[[]]})

在线尝试！

输出1或1,0输入是否完美配对（0,0如果不是）。

无评论版本，156字节

(()){{{}({<<(({}<<>>)<<>>[({{}((<<[[]]>>)){}}{}(<<[]>>){{}{}}{})]){{((<<>>)<<>>)}}{{}{}{}}{}{}<<>>>>{}<<>>}<<>>)}}{{}{}}{}((){<<>>[[]]})(<<()()>>){{}{}{}}{}

在线尝试！

正如Cat Wizard指出的那样，第一个答案不适用于所有口译员，因为不是所有人都可以处理#注释。这个版本没有评论。

Japt，24个 22字节

输出false为真和true为假。

&&!!e"(.)%1"PP"1%).("e

试试吧

Brain-Flak，96字节

{<<>>(({})<<>>[(([{}<<>>]))]){((<<[[]]>>))}{}{}{}{}<<>>}<<>>{{{}{}{}{}{}}((<<>>){{}{}}){{{}}}}{}

在线尝试！

如果输入完美配对，则不输出任何内容，0否则输出。

非完全配对（原始）版本：

{<>(({})<>[({}<>)]){((<()>))}{}{}{}<>}<>{((<>))}{}

在线尝试！

Haskell，66个字节

null.foldr((%))"";;cc%((r:t))|cc==r=t;;t%s=t:s--s:t=s%=r|t:dlof.un

在线尝试！

Cat向导节省了6个字节。

加++，146字节

D,g,@~~,L2_|*;;*|_2L,@,g,D
D,ff,@^^,BG€gBF;;FBg€GB,@D1:?:

xx:?

aa:1
`bb
Bxx;;B
Waa*bb,`yy,$ff>xx,`aa,xx|yy,`bb,Byy,xx:yy

O;;O:,B,`,|,`,>$,`,*W`

在线尝试！

有趣的事实：在开始解释之前，这是272个字节长，现在已经超过Java。

True完美平衡弦的输出，False否则

令我感到非常满意的是，这比无聊的palindromize版本少了2个字节，以防止结果被打印两次。我的目标也是使死代码尽可能少，但是仍然有一些注释掉的部分，并且在打印正确的值后，代码以错误代码1退出。

注：用一个错误BF的命令是固定的，而这个答案是发展。

怎么运行的

$\mathit{ff}$$g$$\mathit{ff}$$\mathit{ff}$$g$$S$$\mathit{ff}(S)$$S$

$S$$abbbaabacc$$[[a], [bbb], [aa], [b], [a], [cc]]$$g$，然后将子列表替换为函数的结果。

$g$$2$$x$$[a]$$[bb]$$[ccc]$

$x$$x > 2$$x - 2$$x$*

$g(s)$$s$BF^D,ff,@^^,$g$$r$$r$;;

$\mathit{ff}$$g$$\mathit{ff}$

• $\mathit{xx}$$\mathit{ff}$
• $\mathit{yy}$$\mathit{ff}$
• $\mathit{aa}$
• $\mathit{bb}$$\mathit{yy}$

$g$$\mathit{xyab}$$g$

€$\mathit{abc}${...}$g${...}$\mathit{gg}$$\mathit{ff}$$g$

D,gg,@~~,L2_|*;;*|_2L,@D             (NB: -2 bytes)
D,ff,@^^,BG€{gg}BF;;FB}gg{€GB,@D?:   (NB: +6 bytes)

长4个字节。

$x = 5$$x = 15$

x+10 ; Explicit argument
+10  ; Implicit argument, as x is active

$x$`

$\mathit{ff}$$g$$\mathit{xx}$xx:?$\mathit{xx}$$\mathit{aa}$aa:1$1$$\mathit{xx}$$\mathit{bb}$

`bb
Bxx

$\mathit{bb}$$\mathit{xx}$$\mathit{aa} := 1$$\mathit{bb} := \neg \neg \mathit{xx}$

然后我们进入while循环：

Waa*bb,`yy,$ff>xx,`aa,xx|yy,`bb,Byy,xx:yy

while循环是Add ++中的一种结构：它直接对代码而不是变量进行操作。构造采用一系列代码语句，并对其进行分离,。while和if语句也要在第一个条件之前紧接一个条件，该条件,由单个有效语句组成，例如带变量的infix命令。需要注意的一件事：活动变量不能从条件中省略。

aa*bb$\mathit{aa}$$\mathit{bb}$$\mathit{yy}$$\mathit{ff}(x)$

`yy,$ff>xx

$\mathit{aa}$

• 1）新值不等于旧值（唯一时循环）
• 2）新值不是空字符串

Add ++最大的缺点之一是缺少复合语句，这需要使用第二个循环变量。我们分配两个变量：

用代码

`aa,xx|yy,`bb,Byy

|B $\mathit{xx}$$\mathit{yy}$xx:yy

$\mathit{ff}$$\mathit{aa}$$\mathit{bb}$

$\mathit{aa}$$\mathit{x} = \mathit{y}$$\mathit{aa}$$\mathit{yy}$$\mathit{bb}$$\mathit{aa}$

然后，我们得出最终声明：

O

$\mathit{bb}$

• $\mathit{aa} = 1$$\mathit{bb} = \mathrm{False}$$\mathrm{False}$
• $\mathit{aa} = \mathrm{True}$$\mathit{bb} = \mathrm{False}$$\mathrm{False}$
• $\mathit{aa} = \mathrm{False}$$\mathit{bb} = \mathrm{True}$$\mathrm{True}$

$\mathit{bb}$$\mathit{bb}$$\mathrm{True}$$\mathrm{False}$

JavaScript（ES6），76个字节

返回一个布尔值。

ff=ss=>ss==(ss=ss.replace(/(.)\1/,''))?!ss:ff(ss)//)(:!?,/1\).(/(ecalper.=(>

在线尝试！

@Shaggy建议：58个字节，返回一个完美配对的空字符串，否则抛出错误。

Wolfram语言（Mathematica），70 64字节

{#//.{aa___,bb__,bb_,cc___}:>{aa,cc}}=={{}}(**(,{>:}_,{.#{&)**)&

在线尝试！

无评论，共92个字节

((#//.bb_:>StringReplace[00[ecalpeRgnirtS>aa__:_.#&];bb,{{,}};00>00;00;aa:_~~aa_:>""]))==""&

在线尝试！

Lua，178字节

p=...S={}for a in p:gmatch"."do E=S[#S]~=a;S[E and#S+1 or#S]=E and a or X end;print(#S==0)--)0S#(tnirp;dne X ro a dna E=]S#ro 1+S#dna E[S;a=~]S#[S=E od"."hctamg:p ni a rof}{=S.=p

在线尝试！

尽管这是一个非常长的解决方案，但这确实使用了Lua特有的怪癖。这实际上是一种最小化的蛮力堆栈算法。由于Lua的模式不允许替换对并且没有内置正则表达式，因此使程序变得复杂。

说明：

p=... -- command-line argument
S={} -- the stack
for c in p:gmatch"." do -- shorter than "for i=1,#p do ..."
    E=S[#S]~=c -- check whether we have the right letter on top of stack
    -- could've saved some bytes by doing == instead of ~=
    -- but the double negation is necessary for ternary operator
    -- to work with nil values
    S[E and #S+1 or #S]=E and c or X -- Lua's awesome "ternary operator"
end
-- i'm sure there is a better way to output this (table indexing?)
print(#S==0)

Gol> <>，30个字节

1ll1**F:}}:{=Q{~~||lzBBzl{Q={F

在线尝试！

第一个之后的所有内容B都是多余的代码，不会执行。该函数返回栈顶，就1好像输入是完美配对一样，0否则返回。

说明：

1       Push 1 as the end string marker
 ll1**  Push n, where n (len+1)*(len+2), 
        This is larger than the amount of steps needed to determine pairing
      F           |  Repeat that many times
       :}}:{=        Compare the first two characters of the string
             Q   |   If they are equal
              {~~    Pop both of them
        String is also rotated by 1
        If the string becomes empty, the 1 is compared to itself and removed.
                   lzB   Return whether the length of the stack is 0
                      Bzl{Q={F  Excess code to match unpaired symbols

Cubix，30个字节

1O@;??;@ii??O;>>;;;..1Wcc1??1W

在线尝试！

1如果字符串完美配对，则输出，否则输出。

集中化

      1 O @
      ; ? ?
      ; @ i
i ? ? O ; > > ; ; ; . .
1 W c c 1 ? ? 1 W . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

简化版

      1 O @
      ; ? .
      . @ .
i ? . . . . > ; ; ; . .
. W c . . . ? 1 W . . .
. . . . . . . . . . . .
      . . .
      . . .
      . . .

逻辑和一般结构与Mnemonic的答案相同，但未明确检查空字符串。

Haskell，92个字节

gg""

gg((aa:cc:bb))dd|aa==cc=gg bb dd

gg  aa""=""==aa

gg  aa((bb:c))=gg((bb:aa))c--c:=c:|

在线尝试！

@nimi的答案很酷，它不使用任何评论。这是较短的，但确实使用了注释。

@xnor的答案也很酷，它确实使用注释，并且比这个简短。

Python 2，114字节

import re

e=lambda i,nn=1:e(*re.subn('(.)\\1','',i))if nn else''==i##ieslef'1).('(nbus.er*(e:1=,i adbmal=r tropmi

在线尝试！

返回True完美配对的字符串，False否则返回。

（实际上无法验证自己，因为(.)与代码中的换行符不匹配！但是@Cat向导说这没关系，因为换行符不是可打印的ASCII字符，所以我的程序不需要处理它们。）

这是以下产品的完美配对版本：

import re;p=lambda s,n=1:p(*re.subn('(.)\\1','',s))if n else''==i

为此，“懒惰”的完善code + '##' + f(code[::-1])将产生120个字节。（也就是说，重命名变量等，以在代码的注释一半内引入更多折叠对，节省了6个字节。）

re.subn是re.sub返回的元组的鲜为人知的变体(new_string, number_of_substitutions_made)。查找正则表达式替代固定点非常好！

果冻，26 24 22字节

ẠƬµF€ḂLḣgŒŒgḣLḂ$$€FµƬẠ

在线尝试！

奇怪的是，在不将向后代码移至未使用的链接的情况下，它可以正常工作。

如果输入完全配对，则返回0，否则返回1。

活动代码：

ŒgḣLḂ$$€FµƬẠ
Œg            Group runs 'abbbcc'->['a','bbb','cc']
       €      For each of these strings:
      $       Monad{
     $            Monad{
   L                  Find the length...
    Ḃ                 ...mod 2. 
                      } -> [1, 1, 0] in this example.
  ḣ               Take this many characters from the string.
                  } -> [['a'], ['b'], []]
        F     Flatten -> ['a', 'b']
          Ƭ   Repeat...
         µ    The last monadic chain until a fixed point is reached.
           Ạ  All. If it is not a perfectly paired string, all elements in the 
              result of Ƭ will be nonempty and 1 is returned.
              If it is perfectly paired, the last element is [] which is falsy
              and 0 is returned.

附件，82字节

{0=#Fixpoint[{Replace[_,/"(.)\\1",""]},_]}??}]_,}],"1).("/,_[ecalpeR{[tniopxiF#=0{

在线尝试！

这里没什么不可思议的。Fixpoint一个删除连续对的函数。

爪哇8，158个 156 154字节

n->{for(;n.matches(".*(.)\\1.*");n=n.replaceAll("(.)\\1",""));return  n.isEmpty();}//};)(ytpmEsi.ruter;,"1).("(Aecalper.n=n;)"*.1).(*."(sehctam.n;(rof{>-n

返回一个布尔值（true/ false）。

-2个字节，感谢@raznagul。

在线尝试。

说明：

n->{                              // Method with String parameter and boolean return-type
  for(;n.matches(".*(.)\\1.*");   //  Loop as long as the String still contains pairs
    n=n.replaceAll("(.)\\1","")); //   Remove all pairs
  return  n.isEmpty();}           //  Return whether the String is empty now
//};)(ytpmEsi.ruter;,"1).("(Aecalper.n=n;)"*.1).(*."(sehctam.n;(rof{>-n
                                  // Comment reversed of the source code,
                                  // minus the pairs: '\\';'ll';'\\';'""))';'n  n';'//'