Chúng ta có một hàm lấy một chuỗi và loại bỏ tất cả các cặp ký tự giống nhau liền kề. Ví dụ$f$

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

Lưu ý rằng khi hai cặp trùng nhau, chúng tôi chỉ loại bỏ một trong số chúng.

Chúng ta sẽ gọi một chuỗi được ghép hoàn hảo nếu ứng dụng lặp lại cuối cùng mang lại chuỗi trống. Ví dụ, chuỗi trên không được ghép hoàn hảo bởi vì nếu chúng ta áp dụng lại f, chúng ta vẫn nhận được a b a . Tuy nhiên, một chuỗi như e a b b c c a d d e được ghép hoàn hảo bởi vì nếu chúng ta áp dụng f ba lần, chúng ta sẽ nhận được chuỗi trống$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}) =$

Nhiệm vụ của bạn là viết mã máy tính được ghép nối hoàn hảo lấy một chuỗi (ASCII có thể in được) và quyết định xem nó có được ghép hoàn hảo hay không. Việc kiểm tra nguồn của bạn phải là một chuỗi được ghép hoàn hảo , mặc dù mã của bạn không nhất thiết phải bị hạn chế đối với ASCII có thể in được.

Bạn có thể xuất hai giá trị riêng biệt: một cho trường hợp đầu vào được ghép hoàn hảo và một giá trị khác cho các trường hợp không có.

Đây là một câu hỏi về môn đánh gôn, vì vậy các câu trả lời sẽ được tính theo kích thước tính theo byte của nguồn với ít byte hơn.

Các trường hợp thử nghiệm

$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 byte

((""##))
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

Miễn bình luận. Trả về Truehoặc False.

Hãy thử trực tuyến!

Chỉnh sửa: -22 byte nhờ @Cat Wizard

Python 2 , 94 byte

ss=''

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

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

Hãy thử trực tuyến!

Toàn bộ bước cập nhật ss=[cc+ss,ss[1:]][cc==ss[:1]]hủy bỏ chỉ =[+,[.

05AB1E , 26 24 22 20 18 byte

-2 byte nhờ vào các lò nướng . Kết quả 0 nếu chuỗi được ghép hoàn hảo, 1 nếu không.

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

Hãy thử trực tuyến!

GÉ} JJ} qqĀÉgʒγΔ - Chương trình đầy đủ.
Δ} - Cho đến khi kết quả không còn thay đổi:
 γʒ} - Chia chuỗi thành các đoạn có ký tự bằng nhau và lọc theo:
   gÉ - Là chiều dài lẻ?
      JJ - Và sau khi lọc, nối các phần lại với nhau, nhưng làm điều này
                     hai lần để lưu 2 byte, như trong các phiên bản trước.
         - Kiểm tra xem kết quả có trống không
          q - Chấm dứt (bỏ) thực thi. Phần còn lại của mã được bỏ qua.
           qĀÉgʒγΔ - Phản chiếu phần không khớp để giúp bố trí nguồn.

Những phiên bản trước

Điều này hoàn toàn dựa vào hành vi không xác định (vì vậy không có "mã chết") và xuất ra [['0']] cho các chuỗi được ghép hoàn hảo và [['1']] cho các chuỗi không khớp hoàn hảo:

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

Và phiên bản 22 byte, được giải thích, chỉ là ở trên nhưng không lạm dụng UB và mang lại các giá trị lành mạnh .

Δγε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.

Khối , 54 byte

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

Kết quả không có gì nếu chuỗi được ghép hoàn hảo và 1ngược lại.
Hãy thử nó ở đây

Tạo khối

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

Giải trình

Hầu hết các ký tự là phụ cần thiết để ghép mã hoàn hảo. Thay thế những người bằng .(no-op), chúng tôi nhận được

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

Điều này có thể được chia thành ba bước:

• Kiểm tra đối với chuỗi trống (bên trái ivà bên trái ?).
• Lặp lại, ném các ký tự lên ngăn xếp và xuất hiện các bản sao (mọi thứ ở phía dưới và bên phải).
• Kiểm tra xem ngăn xếp có trống không (các công cụ ở trên cùng).

V , 20 , 18 byte

òóˆ±òø‚

::‚øò±ˆóò

Hãy thử trực tuyến!

Hexdump:

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

Đầu ra 0 cho sự thật, 1 cho giả. Cảm ơn nmjcman101 vì đã gián tiếp lưu 2 byte.

ò        ò        " 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 , 142 126 byte

Logic chặt chẽ hơn và một số byte nhận xét được chơi bởi @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

Hãy thử trực tuyến!

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

Nguyên:

Hãy thử trực tuyến!

Hàm dò đệ quy theo sau là nhận xét với tất cả các ký tự trong hàm theo thứ tự ngược lại.

APL (Dyalog) , 38 byte

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

Hãy thử trực tuyến!

Võng mạc , 28 26 byte

+`(.)\1

C`^$

$^`C1\).(`+

Hãy thử trực tuyến!

Đầu ra `C1\).(`+0`C1\).(`+cho giả và `C1\).(`+1`C1\).(`+cho các trường hợp trung thực.

Brain-Flak , 228 200 byte

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

Hãy thử trực tuyến!

Đây là một chút của một bằng chứng về khái niệm. Nó có thể ngắn hơn. Nó không sử dụng bất kỳ ý kiến ​​tuy nhiên.

Đầu ra 0,0nếu đầu vào được ghép hoàn hảo và 0,1nếu đầu vào không.

sed 4.2.2 , 34 byte

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

Hãy thử trực tuyến!

Các chuỗi kết hợp cho đầu ra trống, các chuỗi không ghép đôi cho ct:

Phiên bản palindromic tầm thường là 32 :;ss(.)\1ss;t;/./cc/./;t;1\).(;:. Giải pháp cũ đã được :;ss((..??\??))\1ss1;t;;/./cc/./t:(thay đổi vì hiện tại đã lạm dụng cít hơn, chỉnh sửa: yay hiện chỉ có 1 ký tự sau c: D)

(lưu ý đó ;là dấu phân cách câu lệnh)

: tuyên bố một nhãn trống

:t tuyên bố nhãn t

ss((..??\??))\1ss1là một sự thay thế, trong sed bạn có thể thay đổi dấu phân cách thành một sự thay thế, và đây là những gì tôi đã làm bằng cách thay đổi nó s, vì vậy cái này thay thế cái đầu tiên (như được biểu thị 1ở cuối)

• trận đấu của ((..??\??))\1

  • . bất kỳ nhân vật
  • .?? theo sau là một nhân vật tùy chọn tùy chọn
  • \?? và một tùy chọn ?
  • tiếp theo là điều tương tự ngay bên cạnh nó

• không có gì

Bây giờ sự thay thế này được ghép nối với chính nó, vì vậy ;s trước và sau khi nó cũng bị hủy

t và lặp lại nhãn cho đến khi không có sự thay thế thành công nào nữa

/..?/if .(ký tự đại diện) theo sau là .?một ký tự tùy chọn được khớp

• cc thay đổi bộ đệm thành c

Brain-Flak , 112 110 108 byte

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

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

Hãy thử trực tuyến!

Điều này dựa trên câu trả lời của tôi từ các dấu ngoặc có khớp không? .

Đã cố gắng không sử dụng các bình luận, nhưng đã bị mắc kẹt khi cố gắng làm cho pop nilads ( {}) ghép nối. Vấn đề nằm ở cách dễ nhất để ghép một cặp dấu ngoặc là bao quanh nó trong một cặp khác cùng loại. Trong khi điều này là dễ dàng cho các nilad khác, {...}đơn nguyên tạo ra các vòng lặp. Để thoát khỏi vòng lặp, bạn phải đẩy 0, nhưng một khi bạn đã thoát khỏi vòng lặp, thì bạn phải bật 0, điều này gây ra vấn đề.

Giải pháp ghép nối trước 66 byte là:

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

Hãy thử trực tuyến!

Đầu ra 1hoặc 1,0nếu đầu vào là một cặp hoàn hảo, 0,0nếu không.

Không có phiên bản bình luận, 156 byte

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

Hãy thử trực tuyến!

Như Cat Wizard đã chỉ ra, câu trả lời đầu tiên không hoạt động đối với tất cả các thông dịch viên, vì không phải tất cả các #bình luận đều xử lý . Phiên bản này không có ý kiến.

Japt, 24 22 byte

Đầu ra falsecho sự thật và truecho falsey.

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

Thử nó

Brain-Flak , 96 byte

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

Hãy thử trực tuyến!

Đầu ra không có gì nếu đầu vào được ghép hoàn hảo, và 0nếu không.

Phiên bản không ghép nối hoàn hảo (bản gốc):

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

Hãy thử trực tuyến!

Haskell , 66 byte

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

Hãy thử trực tuyến!

Cat Wizard đã lưu 6 byte.

Thêm ++ , 146 byte

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`

Hãy thử trực tuyến!

Sự thật thú vị: Điều này đã dài 272 byte trước khi giải thích được bắt đầu, bây giờ nó đã vượt qua Java.

Đầu ra Truecho các chuỗi cân bằng hoàn hảo, và Falsenếu không

Tôi rất hài lòng, điều này đánh bại phiên bản palindromize nhàm chán thêm 2 byte, để ngăn kết quả được in hai lần. Tôi cũng đã nhắm đến việc có càng ít mã chết càng tốt, tuy nhiên vẫn còn một số phần nhận xét và mã thoát với mã lỗi là 1 , sau khi in giá trị chính xác.

NB : Một lỗi với các BFlệnh đã được sửa trong khi câu trả lời này đang được phát triển.

Làm thế nào nó hoạt động

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

$S$$abbbaabacc$$[[a], [bbb], [aa], [b], [a], [cc]]$$g$và thay thế danh sách con bằng kết quả của hàm.

$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)

dài hơn 4 byte.

$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}$

Sau đó, chúng tôi nhập vòng lặp while của chúng tôi:

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

Một vòng lặp while là một cấu trúc trong Add ++: nó hoạt động trực tiếp trên mã, thay vì các biến. Các constructor lấy một loạt các câu lệnh mã, tách biệt với ,chúng mà chúng hoạt động. Các câu lệnh while và if cũng lấy một điều kiện trực tiếp trước câu lệnh đầu tiên ,bao gồm một câu lệnh hợp lệ duy nhất, chẳng hạn như lệnh infix với các biến. Một điều cần lưu ý: biến hoạt động không thể được bỏ qua khỏi điều kiện.

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

`yy,$ff>xx

$\mathit{aa}$

• 1) Giá trị mới không bằng giá trị cũ (vòng lặp trong khi duy nhất)
• 2) Giá trị mới không phải là chuỗi rỗng

Một trong những nhược điểm lớn nhất của Add ++ là thiếu các câu lệnh ghép, đòi hỏi phải có biến vòng lặp thứ hai. Chúng tôi chỉ định hai biến của chúng tôi:

Với mã

`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}$

Sau đó chúng tôi đạt được tuyên bố cuối cùng của chúng tôi:

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 byte

Trả về một boolean.

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

Hãy thử trực tuyến!

Được đề xuất bởi @Shaggy: 58 byte bằng cách trả về một chuỗi trống để ghép hoàn hảo hoặc ném lỗi khác.

Ngôn ngữ Wolfram (Mathicala) , 70 64 byte

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

Hãy thử trực tuyến!

Không có ý kiến, 92 byte

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

Hãy thử trực tuyến!

Lua , 178 byte

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

Hãy thử trực tuyến!

Mặc dù nó là một giải pháp dài khủng khiếp, nhưng điều này thực hiện khá nhiều việc sử dụng các quirks dành riêng cho Lua. Đây thực sự là một thuật toán ngăn xếp vũ lực tối giản. Chương trình được thực hiện phức tạp bởi thực tế là các mẫu của Lua không cho phép thay thế các cặp và regex không được tích hợp.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Tất cả mọi thứ sau lần đầu tiên Blà mã thừa và không được thực thi. Một hàm trả về đỉnh của ngăn xếp như 1thể đầu vào là một cặp hoàn hảo, 0nếu không.

Giải trình:

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

Khối , 30 byte

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

Hãy thử trực tuyến!

Đầu ra 1nếu chuỗi được ghép hoàn hảo và không có gì khác.

Tạo khối

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

giản thể

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

Logic và cấu trúc chung giống như trong câu trả lời của Mnemonic, nhưng không có kiểm tra rõ ràng cho chuỗi trống.

Haskell , 92 byte

gg""

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

gg  aa""=""==aa

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

Hãy thử trực tuyến!

Câu trả lời của @ nimi khá tuyệt, nó không sử dụng bất kỳ bình luận nào. Cái này ngắn hơn nhưng không sử dụng bình luận.

Câu trả lời của @ xnor cũng khá tuyệt, nó sử dụng các bình luận và ngắn hơn câu trả lời này.

Python 2 , 114 byte

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

Hãy thử trực tuyến!

Trả về Truecho các chuỗi được ghép hoàn hảo, Falsenếu không.

(Trên thực tế không thể tự xác minh, vì (.)sẽ không khớp với các dòng mới trong mã! Nhưng @Cat Wizard cho biết điều này không sao, vì các dòng mới không thể in các ký tự ASCII, vì vậy chương trình của tôi không cần xử lý chúng.)

Đây là phiên bản được ghép nối hoàn hảo của:

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

trong đó một sự hoàn thiện của những người lười biếng trên mạng code + '##' + f(code[::-1])sẽ cho ra 120 byte. (Nghĩa là đổi tên các biến, v.v. để giới thiệu các cặp được thu gọn hơn bên trong nửa bình luận của mã được lưu 6 byte.)

re.subnlà một biến thể ít được biết đến re.submà trả về một tuple (new_string, number_of_substitutions_made). Nó khá tốt cho việc tìm kiếm các điểm cố định thay thế regex!

Thạch , 26 24 22 byte

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

Hãy thử trực tuyến!

Thật kỳ lạ dường như làm việc mà không di chuyển mã ngược đến một liên kết không sử dụng.

Trả về 0 nếu đầu vào được ghép hoàn hảo, 1 nếu không.

Mã kích hoạt:

Œ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.

Tùy viên , 82 byte

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

Hãy thử trực tuyến!

Không có gì đáng kinh ngạc ở đây. Fixpointchức năng sa loại bỏ các cặp liên tiếp.

Java 8, 158 156 154 byte

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

Trả về một boolean ( true/ false).

-2 byte nhờ @raznagul .

Hãy thử trực tuyến.

Giải trình:

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';'//'