Załóżmy funkcję która pobiera ciąg znaków i usuwa wszystkie pary sąsiednich identycznych znaków. Na przykład$f$

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

Zauważ, że gdy dwie pary zachodzą na siebie, usuwamy tylko jedną z nich.

Wywołamy łańcuch idealnie sparowany, jeśli powtarzająca się aplikacja ostatecznie zwróci pusty łańcuch. Na przykład ciąg powyżej nie jest idealnie sparowany, ponieważ jeśli zastosujemy ponownie , nadal otrzymamy . Jednak ciąg taki jak jest idealnie sparowany, ponieważ jeśli zastosujemy f trzy razy, otrzymamy pusty ciąg$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}) =$

Twoim zadaniem jest napisanie idealnie sparowanego kodu komputerowego, który pobiera ciąg (drukowalnego ASCII) i decyduje, czy jest idealnie sparowany. Bajtowanie źródła musi samo w sobie być idealnie sparowanym ciągiem , chociaż kod niekoniecznie musi być ograniczony do drukowalnego ASCII.

Możesz wyprowadzić dwie różne wartości: jedną dla przypadku, w którym dane wejściowe są idealnie sparowane, a drugiego dla przypadków, w których nie jest.

To jest pytanie w golfa kodu, więc odpowiedzi będą oceniane według wielkości w bajtach źródła, przy czym mniej bajtów jest lepszych.

Przypadki testowe

$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 bajtów

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

Bez komentarza. Zwraca albo Truealbo False.

Wypróbuj online!

Edycja: -22 bajtów dzięki @Cat Wizard

Python 2 , 94 bajty

ss=''

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

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

Wypróbuj online!

Cały krok aktualizacji ss=[cc+ss,ss[1:]][cc==ss[:1]]anuluje się do just =[+,[.

05AB1E , 26 24 22 20 18 bajtów

-2 bajty dzięki ovs . Zwraca 0, jeśli łańcuch jest idealnie sparowany, w przeciwnym razie 1 .

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

Wypróbuj online!

ΔγʒgÉ} JJ} ĀqqĀÉgʒγΔ - Pełny program.
Δ} - Dopóki wynik już się nie zmienia:
 γʒ} - Podziel ciąg na części równych znaków i filtruj według:
   gÉ - Czy długość jest dziwna?
      JJ - Po przefiltrowaniu połącz części z powrotem, ale zrób to
                     dwa razy, aby zapisać 2 bajty, tak jak w poprzednich wersjach.
         Ā - Sprawdź, czy wynik jest pusty
          q - Zakończ (zakończ) wykonywanie. Reszta kodu jest ignorowana.
           qĀÉgʒγΔ - Odzwierciedla niedopasowaną część, aby pomóc w układzie źródła.

Poprzednie wersje

Ten opiera się wyłącznie na niezdefiniowanym zachowaniu (więc nie ma „martwego kodu”) i zwraca [['0']] dla idealnie sparowanych ciągów i [['1']] dla niedopasowanych ciągów:

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

I 22-bajtowa wersja, wyjaśniona, która jest tylko powyższym, ale nie nadużywającym UB, i dająca rozsądne wartości.

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

U#;[email protected]>??>i..??O.@1^^...u--u.u!ww;..#..U..;..;!^^!

Nie wyprowadza nic, jeśli łańcuch jest idealnie sparowany i 1inaczej.
Wypróbuj tutaj

Cubified

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

Wyjaśnienie

Większość znaków to wypełniacze potrzebne do idealnego sparowania kodu. Zastępujemy je .(no-op), otrzymujemy

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

Można to podzielić na trzy etapy:

• Sprawdź pusty ciąg (lewy ii lewy ?).
• Pętla, rzucanie postaci na stos i strzelanie duplikatami (wszystko na dole i po prawej).
• Sprawdź, czy stos jest pusty (rzeczy na górze).

V , 20 , 18 bajtów

òóˆ±òø‚

::‚øò±ˆóò

Wypróbuj online!

Hexdump:

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

Wyprowadza 0 dla prawdy, 1 dla fałszu. Dzięki nmjcman101 za pośrednie oszczędzanie 2 bajtów.

ò        ò        " 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 bajtów

Ścisła logika i niektóre bajty komentowane przez golfa @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

Wypróbuj 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

Oryginalny:

Wypróbuj online!

Funkcja detektora rekurencyjnego, po której następuje komentarz ze wszystkimi znakami w funkcji w odwrotnej kolejności.

APL (Dyalog) , 38 bajtów

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

Wypróbuj online!

Retina , 28 26 bajtów

+`(.)\1

C`^$

$^`C1\).(`+

Wypróbuj online!

Wyjścia `C1\).(`+0`C1\).(`+dla falsy i `C1\).(`+1`C1\).(`+dla truthy przypadkach.

Brain-Flak , 228 200 bajtów

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

Wypróbuj online!

To jest trochę dowód koncepcji. Prawdopodobnie może być krótszy. Nie używa jednak żadnych komentarzy.

Wyprowadzane, 0,0jeśli wejście jest idealnie sparowane, a 0,1jeśli wejście nie jest.

sed 4.2.2 , 34 bajty

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

Wypróbuj online!

Sparowane ciągi dają pusty wynik, niesparowane dają ct:

Trywialna wersja palindromowa ma 32 lata :;ss(.)\1ss;t;/./cc/./;t;1\).(;:. Stare rozwiązanie zostało :;ss((..??\??))\1ss1;t;;/./cc/./t:(zmienione, ponieważ obecne cmniej nadużywa , edytuj: tak, teraz jest tylko 1 znak po c: D)

(zwróć uwagę, że ;jest to separator instrukcji)

: deklaruje pustą etykietę

:t deklaruje etykietę t

ss((..??\??))\1ss1jest podstawieniem, w sed możesz zmienić separator na podstawienie, i to właśnie zrobiłem, zmieniając na s, więc to, co robi, zastępuje pierwszy (jak oznaczono 1na końcu)

• dopasowanie ((..??\??))\1

  • . dowolna postać
  • .?? a następnie opcjonalny opcjonalny znak
  • \?? i opcjonalnie ?
  • po nim to samo

• z niczym

Teraz podstawienie jest sparowane ze sobą, więc ;s przed i po nim również zostaną anulowane

t i zapętlić z powrotem do etykiety, aż nie będzie już udanych podmiany

/..?/if .(znak wieloznaczny), po którym następuje .?znak opcjonalny

• cc zmień bufor na c

Brain-Flak , 112 110 108 bajtów

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

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

Wypróbuj online!

Jest to oparte na mojej odpowiedzi z Czy nawiasy są dopasowane? .

Próbowałem nie używać komentarzy, ale utknąłem próbując sparować pop nilads ( {}). Problem polega na tym, że najłatwiejszym sposobem na sparowanie pary wsporników jest otoczenie ich inną parą tego samego rodzaju. Chociaż jest to łatwe dla innych nilad, {...}monada tworzy pętle. Aby wyjść z pętli, musisz nacisnąć 0, ale po wyjściu z pętli musisz zerować 0, co komplikuje problem.

66-bajtowe wstępnie sparowane rozwiązanie to:

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

Wypróbuj online!

Wyjścia 1lub 1,0jeśli wejście jest idealnym parowaniem, 0,0jeśli nie.

Brak wersji komentarza, 156 bajtów

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

Wypróbuj online!

Jak zauważył Cat Wizard, pierwsza odpowiedź nie działa dla wszystkich tłumaczy, ponieważ nie wszystkie obsługują #komentarze. Ta wersja nie zawiera komentarzy.

Japt, 24 22 bajtów

Wyjścia falsedla truthy i truedla falsey.

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

Spróbuj

Brain-Flak , 96 bajtów

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

Wypróbuj online!

Nie wyprowadza nic, jeśli dane wejściowe są idealnie sparowane, i 0inaczej.

Niezupełnie sparowana (oryginalna) wersja:

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

Wypróbuj online!

Haskell , 66 bajtów

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

Wypróbuj online!

Kreator Cat zapisał 6 bajtów.

Dodaj ++ , 146 bajtów

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`

Wypróbuj online!

Ciekawostka: na długo przed uruchomieniem wyjaśnienia było 272 bajty, teraz pokonuje Javę.

Wyjścia Truedla idealnie zbalansowanych ciągów znaków i Falsenie tylko

Ku mojej wielkiej satysfakcji pokonuje nudną wersję palindromize o 2 bajty, aby zapobiec dwukrotnemu wydrukowaniu wyniku. Starałem się również mieć jak najmniej martwego kodu, ale wciąż jest kilka skomentowanych sekcji, a kod wychodzi z kodem błędu 1 , po wydrukowaniu poprawnej wartości.

NB : błąd z BFpoleceniami została ustalona podczas gdy ta odpowiedź była w rozwoju.

Jak to działa

Kod zaczyna się od zdefiniowania dwóch kluczowych funkcji, $\mathit{ff}$ i $g$. These two functions are used to calculate the next step in the process of removing pairs, and work entirely from $\mathit{ff}$ i.e. only $\mathit{ff}$ is called from the main program, never $g$. If we define the input string as $S$, $\mathit{ff}(S)$ modifies $S$ in the following way:

First, identical adjacent characters in $S$ are grouped together. For an example of $abbbaabacc$, this yields the array $[[a], [bbb], [aa], [b], [a], [cc]]$. Over each of the sublists (i.e. the identical groups), we run the function $g$, and replace the sublists with the result of the function.

$g$ starts by unpacking the group, splatting the characters onto the stack. It then pushes the number of characters on the stack and takes the absolute difference with $2$ and that number. We'll call this difference $x$. Lets see how this transforms the respective inputs of $[a]$, $[bb]$ i $[ccc]$:

Jak widzisz $x$wskazuje, ile kolejnych znaków chcemy zachować. W przypadku prostych par usuwamy je całkowicie (uzyskując 0 następnego znaku), w przypadku samotnych postaci pozostawiamy je nietknięte lub dajemy 1 z nich, a dla grup, w których$x > 2$, we want $x - 2$ of the character. In order to generate $x$ of the character, we repeat the character with *, and the function naturally returns the top element of the stack: the repeated string.

After $g(s)$ has been mapped over each group $s$, we splat the array to the stack to get each individual result with BF. Finally, the ^ flag at the function definition (D,ff,@^^,) tells the return function to concatenate the strings in the stack and return them as a single string. For pairs, which yielded the empty string from $g$, this essentially removes them, as the empty string concatenated with any string $r$ results in $r$. Anything after the two ;; is a comment, and is thus ignored.

Pierwsze dwa wiersze definiują dwie funkcje, $\mathit{ff}$ i $g$, ale nie wykonuj $\mathit{ff}$jeszcze Następnie pobieramy dane wejściowe i przechowujemy je w pierwszej z naszych 4 zmiennych. Te zmienne to:

• $\mathit{xx}$ : Wstępne dane wejściowe i poprzedni wynik zastosowania $\mathit{ff}$
• $\mathit{yy}$ : Aktualny wynik zastosowania $\mathit{ff}$
• $\mathit{aa}$ : Warunek pętli
• $\mathit{bb}$ : Czy $\mathit{yy}$ jest prawdą

Jak widać, wszystkie zmienne i funkcje (oprócz $g$) mają nazwy dwuliterowe, co pozwala dość szybko usunąć je z kodu źródłowego, zamiast komentarza ze znaczną ilością $\mathit{xyab}$. $g$ nie robi tego z jednego głównego powodu:

Jeśli operator, taki jak €, zostanie przejechany przez funkcję zdefiniowaną przez użytkownika$\mathit{abc}$, należy zawrzeć nazwę funkcji {...}, aby operator mógł pobrać całą nazwę. Jeśli jednak nazwa jest pojedynczym znakiem, takim jak$g$, {...}można pominąć. W takim przypadku, jeśli nazwa funkcji to$\mathit{gg}$, kod dla$\mathit{ff}$ i $g$ musiałby zmienić na

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

który jest 4 bajty dłuższy.

Ważnym terminem, który należy teraz wprowadzić, jest zmienna aktywna . Wszystkie polecenia oprócz przypisania przypisują swoją nową wartość do zmiennej aktywnej, a jeśli aktywna jest zmienna aktywna, można ją pominąć w argumentach funkcji. Na przykład, jeśli aktywną zmienną jest$x = 5$, a następnie możemy ustawić $x = 15$ przez

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

Aktywna zmienna to $x$domyślnie, ale można to zmienić za pomocą `polecenia. Podczas zmiany aktywnej zmiennej należy pamiętać, że nowa aktywna zmienna nie musi wcześniej istnieć i jest automatycznie przypisywana jako 0.

Po zdefiniowaniu $\mathit{ff}$ i $g$, przypisujemy dane wejściowe do $\mathit{xx}$z xx:?. Następnie musimy bardzo nieznacznie manipulować warunkami pętli. Po pierwsze, chcemy się upewnić, że wejdziemy w pętlę while, chyba że$\mathit{xx}$jest pusty. Dlatego przypisujemy prawdziwą wartość$\mathit{aa}$z aa:1najkrótszą taką wartością$1$. Następnie przypisujemy prawdziwość$\mathit{xx}$ do $\mathit{bb}$ z dwiema liniami

`bb
Bxx

Który pierwszy robi $\mathit{bb}$ aktywna zmienna, a następnie uruchamia komendę boolean $\mathit{xx}$. Odpowiednie wybory$\mathit{aa} := 1$ i $\mathit{bb} := \neg \neg \mathit{xx}$ materia, jak pokażemy później.

Następnie wchodzimy do naszej pętli while:

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

Pętla while jest konstrukcją w Add ++: działa bezpośrednio na kodzie, a nie na zmiennych. Konstrukty pobierają szereg instrukcji kodu, oddzielonych za pomocą ,których działają. Instrukcje while i if przyjmują również warunek bezpośrednio przed pierwszym, ,który składa się z jednej poprawnej instrukcji, takiej jak polecenie infiksowe ze zmiennymi. Należy zauważyć: aktywnej zmiennej nie można pominąć w warunku.

Pętla while składa się z warunku aa*bb. Oznacza to zapętlenie podczas gdy oba$\mathit{aa}$ i $\mathit{bb}$są prawdomówni. Najpierw tworzy treść kodu$\mathit{yy}$ aktywna zmienna w celu przechowywania wyniku $\mathit{ff}(x)$. Odbywa się to za pomocą

`yy,$ff>xx

Następnie aktywujemy warunek pętli $\mathit{aa}$. Mamy dwa warunki do ciągłego zapętlania:

• 1) Nowa wartość nie jest równa starej wartości (pętla jest unikalna)
• 2) Nowa wartość nie jest pustym ciągiem

Jedną z największych wad Add ++ jest brak instrukcji złożonych, co wymaga posiadania drugiej zmiennej pętli. Przypisujemy dwie zmienne:

Z kodem

`aa,xx|yy,`bb,Byy

Gdzie |jest operatorem nierówności i B konwertuje na wartość logiczną . Następnie aktualizujemy$\mathit{xx}$ zmienna ma być $\mathit{yy}$zmienna z xx:yy, w przygotowaniu do następnej pętli.

Ta pętla while ostatecznie redukuje dane wejściowe do jednego z dwóch stanów: pustego ciągu lub stałego ciągu, nawet gdy jest zastosowany $\mathit{ff}$. Kiedy tak się stanie$\mathit{aa}$ lub $\mathit{bb}$ skutkują False, wyłamując się z pętli.

Po przerwaniu pętli może ona zostać zerwana z jednego z dwóch powodów, jak wspomniano powyżej. Następnie wyprowadzamy wartość$\mathit{aa}$. Jeśli pętla została przerwana z powodu$\mathit{x} = \mathit{y}$, a następnie zarówno dane wyjściowe, jak i $\mathit{aa}$są fałszywe. Jeśli pętla została przerwana, ponieważ$\mathit{yy}$ był więc równy pustemu ciągowi znaków $\mathit{bb}$ jest falsy i $\mathit{aa}$ a wyniki są zgodne z prawdą.

We then reach our final statement:

O

Program może teraz znajdować się w jednym z trzech stanów, w których znajduje się aktywna zmienna $\mathit{bb}$:

• 1) Dane wejściowe były puste. W tym przypadku pętla nie uruchomiła się,$\mathit{aa} = 1$ i $\mathit{bb} = \mathrm{False}$. Prawidłowe wyjście to$\mathrm{False}$.
• 2) Wejście było idealnie zbalansowane. Jeśli tak, pętla biegnie,$\mathit{aa} = \mathrm{True}$ i $\mathit{bb} = \mathrm{False}$. Prawidłowe wyjście to$\mathrm{False}$
• 3) Wejście nie było idealnie zbalansowane. Jeśli tak, pętla biegnie,$\mathit{aa} = \mathrm{False}$ i $\mathit{bb} = \mathrm{True}$. Prawidłowe wyjście to$\mathrm{True}$

Jak widzisz, $\mathit{bb}$jest równy oczekiwanemu wynikowi (aczkolwiek odwrócony od logicznej odpowiedzi), więc po prostu go wysyłamy. Ostatnie bajty, które pomagają nam pokonać Javę, pochodzą właśnie z tego$\mathit{bb}$ jest aktywną zmienną, więc można ją pominąć w argumencie, pozostawiając nam wyjście $\mathrm{True}$ lub $\mathrm{False}$, w zależności od tego, czy sygnał wejściowy jest idealnie zbalansowany, czy nie.

JavaScript (ES6), 76 bajtów

Zwraca wartość logiczną.

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

Wypróbuj online!

Sugerowane przez @Shaggy: 58 bajtów poprzez zwrócenie pustego łańcucha w celu idealnego sparowania lub zgłoszenie błędu w inny sposób.

Wolfram Language (Mathematica) , 70 64 bajtów

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

Wypróbuj online!

Bez komentarzy, 92 bajty

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

Wypróbuj online!

Lua , 178 bajtów

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

Wypróbuj online!

Choć jest to strasznie długie rozwiązanie, w dużym stopniu wykorzystuje dziwactwa charakterystyczne dla Lua. Jest to właściwie algorytm zminimalizowanego stosu sił. Program komplikuje fakt, że wzorce Lua nie pozwalają na zamianę par, a wyrażenie regularne nie jest wbudowane.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Wszystko po pierwszym Bjest kodem nadmiarowym i nie jest wykonywane. Funkcja, która zwraca górę stosu, tak 1jakby wejście było idealnym parowaniem, w 0przeciwnym razie.

Wyjaśnienie:

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 bajtów

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

Wypróbuj online!

Wyjścia 1 jeśli łańcuch jest idealnie sparowany i nic innego.

Cubified

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

Uproszczony

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

Logika i ogólna struktura są takie same jak w odpowiedzi Mnemonica, ale bez wyraźnego sprawdzenia pustego ciągu.

Haskell , 92 bajty

gg""

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

gg  aa""=""==aa

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

Wypróbuj online!

Odpowiedź @ nich jest całkiem fajna, nie używa żadnych komentarzy. Ten jest krótszy, ale używa komentarza.

Odpowiedź @ xnora jest również całkiem fajna, wykorzystuje komentarze i jest krótsza niż ta.

Python 2 , 114 bajtów

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

Wypróbuj online!

Zwraca Trueza idealnie sparowane ciągi,False przeciwnym razie.

(W rzeczywistości nie weryfikuje się, ponieważ (.)nie pasuje do nowych linii w kodzie! Ale @Cat Wizard powiedział, że jest to w porządku, ponieważ nowe linie nie są drukowalnymi znakami ASCII, więc mój program nie musi ich obsługiwać).

To jest idealnie sparowana wersja:

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

dla których „leniwsze” doskonalenie code + '##' + f(code[::-1])dałoby 120 bajtów. (Oznacza to zmianę nazwy zmiennych itp., Aby wprowadzić więcej zwiniętych par wewnątrz komentarza, w połowie kodu zapisano 6 bajtów.)

re.subnjest mało znanym wariantem, re.subktóry zwraca krotkę (new_string, number_of_substitutions_made). Jest całkiem dobry do znalezienia punktów stałych podstawienia wyrażenia regularnego!

Galaretka , 26 24 22 bajtów

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

Wypróbuj online!

Dziwnie wydaje się działać bez przenoszenia wstecznego kodu na nieużywany link.

Zwraca 0, jeśli wejście jest idealnie sparowane, 1 przeciwnym razie .

Aktywny kod:

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

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

Wypróbuj online!

Nic niesamowitego tutaj. Fixpointfunkcja, która usuwa kolejne pary.

Java 8, 158 156 154 bajtów

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

Zwraca wartość logiczną ( true/false ).

-2 bajty dzięki @raznagul .

Wypróbuj online.

Wyjaśnienie:

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