문자열을 취하고 인접한 동일한 문자의 모든 쌍을 제거 하는 함수 를 보자 . 예를 들어$f$

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

두 쌍이 겹치면 그중 하나만 제거합니다.

반복되는 응용 프로그램이 결국 빈 문자열을 생성하면 완벽하게 쌍을 이루는 문자열을 호출합니다. 예를 들어 위의 문자열 B의 B B C C는 우리가 적용하는 경우 때문에 완벽하게 연결되어 있지 f를 다시 우리는 여전히 얻을 을 b를 . 그러나 e a b b c c a d d e 와 같은 문자열 은 완벽하게 짝을 이룹니다. f를 세 번 적용 하면 빈 문자열이 생깁니다.$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로 제한 될 필요는 없지만 소스의 바이트 스트링 자체는 완벽하게 쌍을 이룬 string이어야합니다 .

입력이 완벽하게 쌍을 이루는 경우와 그렇지 않은 경우를위한 두 가지 고유 한 값을 출력 할 수 있습니다.

이것은 코드 골프 질문이므로 답변은 바이트 수가 적을수록 바이트 단위로 점수가 매겨집니다.

테스트 사례

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

하스켈, 146124 바이트

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

온라인으로 사용해보십시오!

편집 : @Cat Wizard 덕분에 -22 바이트

파이썬 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 바이트

ovs 덕분에 -2 바이트 . 출력 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그렇지 않으면 아무것도 출력하지 않습니다.
여기 사용해보십시오

Cubified

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

설명

대부분의 문자는 코드를 완벽하게 페어링하는 데 필요한 필러입니다. 그것들을 .(no-op)로 바꾸면

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

이것은 세 단계로 나눌 수 있습니다.

• 빈 문자열 (왼쪽 i및 ?)을 확인하십시오.
• 반복하여 문자를 스택에 던지고 복제물이 튀어 나옵니다 (아래와 오른쪽의 모든 것).
• 스택이 비어 있는지 확인하십시오 (맨 위의 물건).

V , 20 , 18 바이트

òóˆ±òø‚

::‚øò±ˆóò

온라인으로 사용해보십시오!

16 진 덤프 :

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

진실은 0을, 거짓은 1을 출력합니다. 간접적으로 2 바이트를 절약 한 nmjcman101 덕분입니다.

ò        ò        " 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\).(`+ 허위 사례에 대한 .

브레인 플락 , 228 200 바이트

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

온라인으로 사용해보십시오!

이것은 약간의 개념 증명입니다. 아마 더 짧을 수 있습니다. 그러나 주석은 사용하지 않습니다.

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.

( ;구문 구분 기호입니다)

: 빈 라벨을 선언

:t 라벨을 선언 t

ss((..??\??))\1ss1sed에서 구분 기호를 대체로 변경할 수 있으며 이것이로 변경하여 수행 한 작업 s이므로 첫 번째 대체입니다 ( 1마지막으로 표시됨)

• ~의 일치 ((..??\??))\1

  • . 어떤 캐릭터
  • .?? 선택적인 선택적 문자가 뒤 따른다
  • \?? 그리고 선택 사항 ?
  • 바로 옆에 같은 것이 있습니다

• 아무것도없이

이제이 대체는 그 자체와 짝을 이루기 때문에 그 ;전후 의 s도 취소됩니다.

t 더 이상 성공적인 대체가 없을 때까지 라벨로 되돌아갑니다.

/..?/만약 .다음 (와일드 카드) .?임의의 문자와 일치

• cc 버퍼를 c

뇌 플랙 , 112 (110) 108 바이트

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

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

온라인으로 사용해보십시오!

이를 기반으로 내 대답 에서 괄호가 일치하고 있는가?.

댓글을 사용하지 않으려 고했지만 팝 nilads ( {})를 페어링 하려고 시도 했습니다. 한 쌍의 브래킷을 페어링하는 가장 쉬운 방법은 같은 종류의 다른 쌍으로 묶는 것입니다. 이것은 다른 nilads에게는 쉽지만 {...}monad는 루프를 만듭니다. 루프를 끝내려면 0을 눌러야하지만 일단 루프를 나간 후에는 0을 팝해야 문제가 발생합니다.

66 바이트 사전 페어링 솔루션은 다음과 같습니다.

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

온라인으로 사용해보십시오!

출력 1또는 1,0입력이 완벽하게 페어링 된 0,0경우 그렇지 않은 경우.

코멘트 버전 없음, 156 바이트

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

온라인으로 사용해보십시오!

Cat Wizard가 지적했듯이 첫 번째 답변은 모든 해석자에게 적용되지는 않으며 모든 #의견을 처리하는 것은 아닙니다 . 이 버전에는 댓글이 없습니다.

apt, 24 22 바이트

출력 falsetruthy 및 truefalsey합니다.

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

시도 해봐

Brain-Flak , 96 바이트

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

온라인으로 사용해보십시오!

입력이 완벽하게 쌍을 이루면 아무 것도 출력하지 0않습니다.

완벽하게 페어링되지 않은 (원본) 버전 :

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

온라인으로 사용해보십시오!

하스켈 , 66 바이트

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

온라인으로 사용해보십시오!

Cat Wizard는 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}$

자바 스크립트 (ES6), 76 바이트

부울을 반환합니다.

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

온라인으로 사용해보십시오!

@Shaggy에서 제안 : 완벽하게 쌍을 이루기 위해 빈 문자열을 반환 하거나 그렇지 않으면 오류를 발생 시켜 58 바이트 .

Wolfram Language (Mathematica) , 70 64 바이트

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

온라인으로 사용해보십시오!

주석없이 92 바이트

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

온라인으로 사용해보십시오!

루아 , 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

온라인으로 사용해보십시오!

그것은 매우 긴 해결책이지만, 이것은 루아 특유의 단점을 상당히 많이 사용합니다. 이것은 실제로 축소 된 무차별 스택 알고리즘입니다. 이 프로그램은 루아의 패턴이 페어 교체를 허용하지 않으며 정규 표현식이 내장되어 있지 않기 때문에 복잡해집니다.

설명:

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문자열이 완벽하게 쌍을 이루고 그렇지 않으면 아무것도 출력 하지 않습니다.

Cubified

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

쉽게 한

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

논리와 일반 구조는 Mnemonic의 답변과 동일하지만 빈 문자열을 명시 적으로 확인하지 않습니다.

하스켈 , 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의 답변 도 꽤 멋지다. 댓글을 사용 하고이 것보다 짧습니다.

파이썬 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 Wizard는 줄 바꿈이 인쇄 가능한 ASCII 문자가 아니기 때문에 괜찮습니다. 그래서 내 프로그램에서 처리 할 필요가 없습니다.)

이것은 완벽하게 쌍을 이룬 버전입니다.

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

"게으른"완벽 화 code + '##' + f(code[::-1])는 120 바이트를 제공합니다. (즉, 변수의 이름을 바꾸면 코드 의 주석 절반 안에 더 축소 된 쌍이 도입되어 6 바이트가 절약됩니다.)

re.subnre.subtuple을 반환 하는 약간 알려진 변형입니다 (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연속적인 쌍을 제거하는 sa 함수.

자바 (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)을 반환합니다 .

@raznagul 덕분에 -2 바이트 .

온라인으로 사용해보십시오.

설명:

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