Lassen Sie uns eine Funktion , die einen String nimmt und alle Paare benachbarter identischer Zeichen entfernt. Beispielsweise$f$

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

Beachten Sie, dass bei Überlappung zweier Paare nur eines entfernt wird.

Wir werden einen String als perfekt gepaart bezeichnen, wenn eine wiederholte Anwendung den leeren String ergibt. Zum Beispiel ist die Zeichenfolge über nicht perfekt gepaart, da wir bei immer noch . Ein String wie ist jedoch perfekt gepaart, denn wenn wir dreimal anwenden, erhalten wir den leeren Stringf ein b ein e ein b b c c ein d d e $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}) =$

Ihre Aufgabe ist es, perfekt gepaarten Computercode zu schreiben, der eine Zeichenfolge (aus druckbarem ASCII) verwendet und entscheidet, ob diese perfekt gepaart ist. Der Bytestring Ihrer Quelle muss selbst ein perfekt gepaarter String sein , obwohl Ihr Code nicht unbedingt auf druckbares ASCII beschränkt sein muss.

Sie können zwei unterschiedliche Werte ausgeben: einen für den Fall, dass die Eingabe perfekt gepaart ist, und einen anderen für den Fall, dass dies nicht der Fall ist.

Dies ist eine Code-Golf- Frage, daher werden die Antworten anhand der Größe in Bytes ihrer Quelle bewertet, wobei weniger Bytes besser sind.

Testfälle

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

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

Keine Kommentare. Gibt entweder Trueoder zurück False.

Probieren Sie es online!

Edit: -22 Bytes dank @Cat Wizard

Python 2 , 94 Bytes

ss=''

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

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

Probieren Sie es online!

Der gesamte Aktualisierungsschritt ss=[cc+ss,ss[1:]][cc==ss[:1]]bricht auf einfach ab =[+,[.

05AB1E , 26 24 22 20 18 Bytes

-2 Bytes dank ovs . Gibt 0 aus, wenn der String perfekt gepaart ist, andernfalls 1 .

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

Probieren Sie es online!

ΔγʒgÉ} JJ} ĀqqĀÉgʒγΔ - Volles Programm.
Δ} - Bis sich das Ergebnis nicht mehr ändert:
 γʒ} - Teilen Sie die Zeichenfolge in gleich große Teile und filtern Sie nach:
   gÉ - Ist die Länge ungerade?
      JJ - Fügen Sie die Teile nach dem Filtern wieder zusammen, tun Sie dies jedoch
                     zweimal, um 2 Bytes zu sparen, wie in den vorherigen Versionen.
         Ā - Prüfen Sie, ob das Ergebnis leer ist
          q - Ausführung beenden. Der Rest des Codes wird ignoriert.
           qĀÉgʒγΔ - Spiegeln Sie das nicht passende Teil, um das Quelllayout zu unterstützen.

Vorherige Versionen

Dieser basiert ausschließlich auf undefiniertem Verhalten (es gibt also keinen "toten Code") und gibt [['0'] für perfekt gepaarte Zeichenfolgen und [['1'] für nicht perfekt passende Zeichenfolgen aus:

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

Und die 22-Byte-Version, erklärt, die genau das oben genannte ist, aber UB nicht missbraucht und vernünftige Werte liefert .

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

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

Gibt nichts aus, wenn der String perfekt gepaart ist 1.
Probieren Sie es hier aus

Cubified

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

Erläuterung

Die meisten Zeichen sind Füllzeichen, die zum perfekten Koppeln des Codes erforderlich sind. Ersetzen .wir diese durch (no-op), erhalten wir

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

Dies kann in drei Schritte unterteilt werden:

• Prüfen Sie die leere Zeichenfolge (die linke iund die ?).
• Schleife, wirf Charaktere auf den Stapel und platziere Duplikate (alles unten und rechts).
• Überprüfen Sie, ob der Stapel leer ist (das Zeug oben).

V , 20 , 18 Bytes

òóˆ±òø‚

::‚øò±ˆóò

Probieren Sie es online!

Hexdump:

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

Gibt 0 für wahr, 1 für falsch aus. Vielen Dank an nmjcman101 für die indirekte Einsparung von 2 Bytes.

ò        ò        " 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 Bytes

Engere Logik und einige Kommentar-Bytes, die von @ Giuseppe gespielt wurden

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

Probieren Sie es online!

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

Original:

Probieren Sie es online!

Rekursive Detektorfunktion, gefolgt von einem Kommentar mit allen Zeichen in der Funktion in umgekehrter Reihenfolge.

APL (Dyalog) , 38 Bytes

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

Probieren Sie es online!

Retina , 28 26 Bytes

+`(.)\1

C`^$

$^`C1\).(`+

Probieren Sie es online!

Ausgaben `C1\).(`+0`C1\).(`+für falsche und `C1\).(`+1`C1\).(`+für wahrheitsgemäße Fälle.

Brain-Flak , 228 200 Bytes

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

Probieren Sie es online!

Dies ist ein bisschen ein Proof of Concept. Es könnte wahrscheinlich kürzer sein. Es werden jedoch keine Kommentare verwendet.

Gibt aus, 0,0ob der Eingang perfekt gepaart ist und 0,1nicht.

sed 4.2.2 , 34 Bytes

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

Probieren Sie es online!

Gepaarte Strings geben leere, ungepaarte Strings geben ct:

Die triviale palindromische Version ist bei 32 :;ss(.)\1ss;t;/./cc/./;t;1\).(;:. Alte Lösung wurde :;ss((..??\??))\1ss1;t;;/./cc/./t:(geändert , weil aktuelle missbraucht cweniger, edit: yay jetzt gibt es nur 1 Zeichen nach c: D)

(Beachten Sie, dass dies ;das Anweisungstrennzeichen ist.)

: deklariert ein leeres Etikett

:t deklariert das Etikett t

ss((..??\??))\1ss1eine Substitution ist, in sed Sie das Trennzeichen auf eine Substitution ändern können, und das ist , was ich , indem es tat s, so wie dies tut , ist die erste ersetzen (wie durch die bezeichnet ist 1am Ende)

• Spiel von ((..??\??))\1

  • . irgendein Charakter
  • .?? gefolgt von einem optionalen optionalen Zeichen
  • \?? und ein optionales ?
  • Gleich daneben folgt das Gleiche

• mit nichts

Jetzt wird diese Ersetzung mit sich selbst gepaart, so dass die ;s davor und danach ebenfalls gelöscht werden

t und kehren Sie zum Etikett zurück, bis keine erfolgreichen Substitutionen mehr vorhanden sind

/..?/if .(Platzhalter) gefolgt von .?einem optionalen Zeichen stimmt überein

• cc Ändern Sie den Puffer in c

Brain-Flak , 112 110 108 Bytes

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

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

Probieren Sie es online!

Dies basiert auf meiner Antwort von Stimmen die Klammern überein? .

Versuchte, keine Kommentare zu verwenden, blieb aber beim Versuch hängen, das {}Paar pop nilads ( ) zusammenzubringen. Das Problem besteht darin, ein Paar von Klammern am einfachsten in einem anderen Paar derselben Art zu umgeben. Während dies für andere Niladen einfach ist, erzeugt die {...}Monade Schleifen. Um die Schleife zu verlassen, müssen Sie eine 0 drücken, aber sobald Sie die Schleife verlassen haben, müssen Sie die 0 platzieren, was das Problem verschärft.

Die vorgepaarte 66-Byte-Lösung ist:

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

Probieren Sie es online!

Ausgänge 1oder 1,0wenn der Eingang eine perfekte Paarung ist, 0,0wenn nicht.

Keine Kommentarversion, 156 Bytes

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

Probieren Sie es online!

Wie der Cat-Assistent hervorhob, funktioniert die erste Antwort nicht für alle Dolmetscher, da nicht alle #Kommentare verarbeiten. Diese Version enthält keine Kommentare.

Japt, 24 22 Bytes

Ausgänge falsefür Wahrheit und trueFalschheit.

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

Versuch es

Brain-Flak , 96 Bytes

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

Probieren Sie es online!

Gibt nichts aus, wenn der Eingang perfekt gepaart ist, 0andernfalls.

Nicht perfekt gepaarte (Original-) Version:

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

Probieren Sie es online!

Haskell , 66 Bytes

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

Probieren Sie es online!

Cat Wizard sparte 6 Bytes.

Add ++ , 146 Bytes

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`

Probieren Sie es online!

Witzige Tatsache: Das waren 272 Bytes, lange bevor die Erklärung gestartet wurde, jetzt schlägt es Java.

Ausgänge Truefür perfekt ausbalancierte Saiten und Falsesonst

Zu meiner großen Zufriedenheit übertrifft dies die langweilige Palindromize-Version um 2 Bytes, um zu verhindern, dass das Ergebnis zweimal gedruckt wird. Ich habe auch versucht, so wenig toten Code wie möglich zu haben, es gibt jedoch noch einige auskommentierte Abschnitte, und der Code wird mit einem Fehlercode von 1 beendet , nachdem der richtige Wert gedruckt wurde.

NB : Ein Fehler mit den BFBefehlen wurde behoben, während diese Antwort in der Entwicklung war.

Wie es funktioniert

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

$S$$abbbaabacc$$[[a], [bbb], [aa], [b], [a], [cc]]$$g$, und ersetzen Sie die Unterlisten durch das Ergebnis der Funktion.

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

Das ist 4 Bytes länger.

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

Dann geben wir unsere while-Schleife ein:

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

Eine while-Schleife ist ein Konstrukt in Add ++: Sie arbeitet direkt mit Code und nicht mit Variablen. Konstrukte verwenden eine Reihe von Code-Anweisungen, mit ,denen sie getrennt arbeiten. While- und If-Anweisungen erhalten auch eine Bedingung direkt vor der ersten, ,die aus einer einzigen gültigen Anweisung besteht, z. B. einem Infix-Befehl mit Variablen. Eines ist zu beachten: Die aktive Variable kann in der Bedingung nicht weggelassen werden.

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

`yy,$ff>xx

$\mathit{aa}$

• 1) Der neue Wert entspricht nicht dem alten Wert (Schleife solange einzigartig)
• 2) Der neue Wert ist nicht die leere Zeichenfolge

Einer der größten Nachteile von Add ++ ist das Fehlen zusammengesetzter Anweisungen, für die eine zweite Schleifenvariable erforderlich ist. Wir ordnen unsere beiden Variablen zu:

Mit dem Code

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

Wir kommen dann zu unserer endgültigen Aussage:

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

Gibt einen Booleschen Wert zurück.

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

Probieren Sie es online!

Vorgeschlagen von @Shaggy: 58 Bytes durch Zurückgeben einer leeren Zeichenfolge für perfektes Pairing oder Auslösen eines Fehlers ansonsten.

Wolfram Language (Mathematica) , 70 64 Bytes

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

Probieren Sie es online!

Ohne Kommentare 92 Bytes

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

Probieren Sie es online!

Lua , 178 Bytes

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

Probieren Sie es online!

Dies ist zwar eine furchtbar lange Lösung, nutzt jedoch Lua-spezifische Macken in erheblichem Maße aus. Dies ist tatsächlich ein minimierter Brute-Force-Stack-Algorithmus. Das Programm wird durch die Tatsache kompliziert, dass Luas Muster das Ersetzen von Paaren nicht erlauben und Regex nicht eingebaut ist.

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Alles nach dem ersten Bist überschüssiger Code und wird nicht ausgeführt. Eine Funktion, die den Anfang des Stapels zurückgibt, als 1wäre die Eingabe 0ansonsten eine perfekte Paarung .

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Gibt aus, 1ob der String perfekt gepaart ist und sonst nichts.

Cubified

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

Vereinfacht

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

Die Logik und die allgemeine Struktur sind die gleichen wie in der Antwort von Mnemonic, jedoch ohne eine explizite Überprüfung der leeren Zeichenfolge.

Haskell , 92 Bytes

gg""

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

gg  aa""=""==aa

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

Probieren Sie es online!

@ Nimis Antwort ist ziemlich cool, es werden keine Kommentare verwendet. Dieser ist kürzer, verwendet aber einen Kommentar.

@ xnors Antwort ist auch ziemlich cool, sie verwendet Kommentare und ist kürzer als diese.

Python 2 , 114 Bytes

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

Probieren Sie es online!

Gibt andernfalls Truefür perfekt gepaarte Zeichenfolgen zurück False.

( (.)Kann sich selbst nicht verifizieren, da die Zeilenumbrüche im Code nicht übereinstimmen. @Cat Wizard hat dies jedoch als in Ordnung eingestuft, da Zeilenumbrüche keine druckbaren ASCII-Zeichen sind und mein Programm sie daher nicht verarbeiten muss.)

Dies ist eine perfekt gepaarte Version von:

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

Wofür eine "faulere" Perfektionierung code + '##' + f(code[::-1])120 Bytes ergeben würde. (Das heißt, das Umbenennen der Variablen usw., um mehr reduzierte Paare in die Kommentarhälfte des Codes einzuführen, sparte 6 Bytes.)

re.subnist eine wenig bekannte Variante re.sub, die ein Tupel zurückgibt (new_string, number_of_substitutions_made). Es ist ziemlich gut, um Fixpoints für die Regex-Substitution zu finden!

Jelly , 26 24 22 Bytes

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

Probieren Sie es online!

Seltsamerweise scheint es zu funktionieren, ohne den Rückwärtscode auf einen nicht verwendeten Link zu verschieben.

Gibt 0 zurück, wenn der Eingang perfekt gepaart ist, andernfalls 1 .

Aktiv-Code:

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

Attache , 82 Bytes

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

Probieren Sie es online!

Nichts Unglaubliches hier. FixpointEine Funktion, die aufeinanderfolgende Paare entfernt.

Java 8, 158 156 154 Bytes

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

Gibt einen Booleschen Wert ( true/ false) zurück.

-2 Bytes dank @raznagul .

Probieren Sie es online aus.

Erläuterung:

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