Bir dizgeyi alan ve bitişik aynı karakterlerin tüm çiftlerini kaldıran bir işlevine sahip olalım . Örneğin$f$

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

İki çift çakıştığında bunlardan yalnızca birini çıkardığımızı unutmayın.

Tekrarlanan uygulama sonunda boş dize verirse mükemmel bir şekilde eşleştirilmiş bir dize arayacağız. Örneğin yukarıdaki dize uyguladığımız çünkü eğer mükemmel eşleştirilmemişse f tekrar biz hala olsun bir b a . Gibi Ancak bir dize e bir b b c c bir d d e biz uygulamak çünkü eğer mükemmel eşlenirse f üç kez biz boş bir dize almak$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}) =$

Göreviniz bir dizeyi (yazdırılabilir ASCII) alan ve mükemmel bir şekilde eşleştirilip eşleşmediğine karar veren mükemmel bir şekilde eşleştirilmiş bilgisayar kodu yazmaktır. Kaynağınızın bytestring kendisi mükemmel bir eşleştirilmiş dize olmalı , ancak kodunuzun yazdırılabilir ASCII ile sınırlı olması gerekmez.

İki farklı değer yazabilirsiniz: biri girişin mükemmel şekilde eşleştirildiği durum için, diğeri ise olmadığı durumlar için.

Bu bir kod-golf sorusudur, bu yüzden cevaplar daha az byte daha iyi olacak şekilde kaynaklarının bayt cinsinden büyüklüğü ile puanlanacaktır.

Test Kılıfları

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

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

Yorum yok. TrueVeya birini döndürür False.

Çevrimiçi deneyin!

Düzenleme: -Cat Sihirbazı sayesinde -22 bayt

Python 2 , 94 bayt

ss=''

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

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

Çevrimiçi deneyin!

Tüm güncelleme adımı ss=[cc+ss,ss[1:]][cc==ss[:1]]sadece iptal eder =[+,[.

05AB1E , 26 24 22 20 18 bayt

Ovs sayesinde -2 bayt . Çıkışlar 0 dize mükemmel eşleştirilmiş ise, 1 aksi.

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

Çevrimiçi deneyin!

}GÉ} JJ} ĀqqĀÉgʒγΔ - Tam program.
Δ} - Sonuç artık değişinceye kadar:
 γʒ} - Dizgiyi eşit karakterdeki parçalara ayırın ve şunlara göre filtreleyin
   gÉ - Uzunluk tuhaf mı?
      JJ - Filtrelemeden sonra parçaları bir araya getirin, ama bunu yapın
                     önceki sürümlerde olduğu gibi 2 bayt kaydetmek için iki kez basın.
         The - Sonucun boş olup olmadığını kontrol edin
          q - İşlemi sonlandır (bırak). Kodun geri kalanı göz ardı edilir.
           qĀÉgʒγΔ - Kaynak düzenine yardımcı olması için eşleşmeyen kısmı yansıtın.

Önceki sürümler

Bu tamamen tanımsız davranışa dayanır (bu nedenle "ölü kod" yoktur) ve mükemmel eşleştirilmiş dizeler için [['0']] ve mükemmel eşleşmeyen dizeler için [['1']] çıkışlarını yapar :

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

Ve 22 baytlık versiyon açıkladı ki bu sadece UB'yi kötüye kullanmıyor, aklı başında değil ve aklı başında değerler veriyor .

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

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

Dize tamamen eşleştirildiyse ve 1başka bir şey yapılmadıysa hiçbir şey çıkarmaz .
Burada dene

Cubified

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

açıklama

Karakterlerin çoğu, kodu mükemmel şekilde eşleştirmek için gerekli olan doldurucudur. Bunları .(no-op) ile değiştirirsek ,

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

Bu üç adıma bölünebilir:

• Boş dizgiye karşı kontrol edin (sol ive ?).
• Döngü, yığına karakter atma ve yinelenen çiftler (alt ve sağdaki her şey).
• Yığının boş olup olmadığını kontrol edin (üst kısımdakiler).

V , 20 , 18 bayt

òóˆ±òø‚

::‚øò±ˆóò

Çevrimiçi deneyin!

HexDump:

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

Gerçek için 0, sahte için 1 çıktı. Dolaylı olarak 2 bayt tasarruf için nmjcman101'e teşekkürler.

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

Daha mantık ve bazı yorumlar bayt @Giuseppe tarafından golf oynadı

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

Çevrimiçi deneyin!

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

Orijinal:

Çevrimiçi deneyin!

Özyinelemeli dedektör işlevi, ardından işlevdeki tüm karakterler ters sırayla yorumlanır.

APL (Dyalog) , 38 bayt

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

Çevrimiçi deneyin!

Retina , 28 26 bayt

+`(.)\1

C`^$

$^`C1\).(`+

Çevrimiçi deneyin!

Çıkışlar `C1\).(`+0`C1\).(`+falsy için ve `C1\).(`+1`C1\).(`+truthy durumlar için.

Brain-Flak , 228 200 bayt

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

Çevrimiçi deneyin!

Bu biraz kavram kanıtı. Muhtemelen daha kısa olabilirdi. Ancak herhangi bir yorum kullanmıyor.

Çıkışlar 0,0giriş mükemmel eşleştirilmiş ise ve 0,1giriş değilse.

sed 4.2.2 , 34 bayt

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

Çevrimiçi deneyin!

Eşleştirilmiş dizeler boş çıktı verir, eşleşmemiş olanlar verir ct:

Önemsiz palindromik versiyonu 32 :;ss(.)\1ss;t;/./cc/./;t;1\).(;:. Eski çözüm :;ss((..??\??))\1ss1;t;;/./cc/./t:(şu anki davranışın cdaha az kötüye kullanılması nedeniyle değiştirildi , düzeltildi: yay şimdi sadece 1 karakterden sonra c: D)

( ;bu ifadenin ayırıcı olduğunu unutmayın )

: boş bir etiket bildirir

:t etiketi bildirir t

ss((..??\??))\1ss1bir sübstitüsyondur, sed'de sınırlayıcıyı bir sübstitüsyona değiştirebilir ve bunu değiştirerek yaptığım şey budur s, yani bunun yaptığı şey ( 1sonunda belirtildiği gibi ) ilk

• eşleşmesi ((..??\??))\1

  • . herhangi bir karakter
  • .?? ardından isteğe bağlı isteğe bağlı bir karakter
  • \?? ve isteğe bağlı ?
  • hemen yanında aynı şeyi izledi

• hiçbir şey ile

Şimdi, bu oyuncu değişikliği kendisi ile eşleştirildi, bu yüzden ;önce ve sonra da iptal edildi

t ve başarılı bir alternatif olmadıkça etikete geri dönün

/..?/if .(joker karakter) ardından .?isteğe bağlı bir karakter eşleşirse

• cc arabellek değiştir c

Brain-Flak , 112 110 108 bayt

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

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

Çevrimiçi deneyin!

Bu dayanmaktadır cevabım gelen parantez eşleşti musunuz? .

Yorumları kullanmamaya çalıştım, ancak pop nilads ( {}) ile eşleşmeye çalışırken sıkışıp kaldım . Sorun, bir çift braketi eşleştirmenin en kolay yolunda aynı türden başka bir çiftle çevrelemektir. Diğer niladlar için bu kolay olsa da, {...}monad döngüler yaratır. Döngüden çıkmak için 0'a basmanız gerekir, ancak döngüden çıktıktan sonra, sorunu oluşturan bileşik 0'ı açmanız gerekir.

66 bayt önceden eşleştirilmiş çözüm:

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

Çevrimiçi deneyin!

Çıktılar 1veya 1,0eğer girdi değilse mükemmel bir eşleşme 0,0ise.

Yorum yok, 156 bayt

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

Çevrimiçi deneyin!

Cat Wizard'ın da belirttiği gibi, ilk cevap tüm yorumlayıcılar gibi tüm tercümanlar için işe yaramıyor #. Bu sürüm yorum içermiyor.

Japt, 24 22 bayt

falseTruthy ve falsey trueiçin çıktılar .

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

Dene

Brain-Flak , 96 bayt

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

Çevrimiçi deneyin!

Giriş tamamen eşleştirilmişse hiçbir şey çıkarmaz ve 0 aksi takdirde.

Mükemmel şekilde eşleştirilmemiş (orijinal) sürüm:

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

Çevrimiçi deneyin!

Haskell , 66 bayt

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

Çevrimiçi deneyin!

Kedi Sihirbazı 6 bayt kurtardı.

++ , 146 bayt ekle

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`

Çevrimiçi deneyin!

Eğlenceli gerçek: Bu açıklama başlamadan çok önce 272 bayttır, şimdi Java'yı yener.

TrueMükemmel dengelenmiş dizgiler için çıktılar , Falseaksi takdirde

Benim büyük memnuniyet için, bu sıkıcı yener palindromize versiyonunu tarafından 2 kez basılmış olan sonuç önlemek için, bayt. Ayrıca, mümkün olduğunca az ölü kodun olmasını da hedefledim, yine de bazı yorumlanmış bölümler var ve kod doğru değeri yazdırdıktan sonra 1 hata koduyla çıkıyor .

Not : BFKomutlarla ilgili bir hata düzeltildi Bu cevap geliştirilirken .

Nasıl çalışır

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

$S$$abbbaabacc$$[[a], [bbb], [aa], [b], [a], [cc]]$$g$, ve işlevlerin sonucu alt listeleri değiştirin.

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

$x$$x > 2$$x - 2$$x$* ve fonksiyon doğal yığının üst eleman verir: tekrar dizisi.

$g(s)$$s$BF^D,ff,@^^,$g$$r$$r$;; bir yorum yorumdur ve bu nedenle dikkate alınmaz.

$\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 bayt daha uzun.

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

Sonra biz while döngüsüne giriyoruz:

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

While döngüsü Add ++ ' da bir yapıdır : değişkenler yerine doğrudan kod üzerinde çalışır. Yapılar, ,üzerinde çalıştıkları bir dizi kod ifadesi alırlar. While ve if ifadeleri ,, değişkenlerden önce bir infix komutu gibi tek bir geçerli ifadeden oluşan ilkinden önce doğrudan bir koşul alır . Unutulmaması gereken bir şey: aktif değişken durumdan çıkarılamaz.

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

`yy,$ff>xx

$\mathit{aa}$

• 1) Yeni değer eski değere eşit değil (benzersiz iken döngü)
• 2) Yeni değer boş dize değil

Add ++ 'nın en büyük dezavantajlarından biri, ikinci bir döngü değişkenine sahip olmayı gerektiren bileşik ifadelerin eksikliğidir. İki değişkenimizi atadık:

Kod ile

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

Daha sonra son ifademize ulaşıyoruz:

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 bayt

Bir boole döndürür.

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

Çevrimiçi deneyin!

@Shaggy tarafından önerildi: Mükemmel bir şekilde eşleştirilmesi için boş bir dize döndürerek veya başka bir hatayı atarak 58 bayt .

Wolfram Dili (Mathematica) , 70 64 bayt

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

Çevrimiçi deneyin!

Yorum olmadan, 92 bayt

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

Çevrimiçi deneyin!

Lua , 178 bayt

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

Çevrimiçi deneyin!

Son derece uzun bir çözüm olsa da, bu Lua'ya özgü tuhaflıklardan oldukça fazla yararlanıyor. Bu aslında küçültülmüş bir kaba kuvvet yığını algoritmasıdır. Program, Lua'nın modellerinin çiftlerin değiştirilmesine izin vermediği ve regex'in yerleşik olmadığı gerçeğiyle karmaşıklaşıyor.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

İlk olandan sonraki her şey Başırı koddur ve yürütülmez. Aksi halde 1girişin üstünü mükemmel bir eşleştirmemiş gibi yığının tepesine döndüren bir fonksiyon0

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

1Dize tamamen eşleştirilmişse ve başka bir şey yoksa, çıktılar .

Cubified

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

Basitleştirilmiş

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

Mantık ve genel yapı, Mnemonic'in cevabındakiyle aynıdır, ancak boş dize için açık bir kontrol olmadan.

Haskell , 92 bayt

gg""

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

gg  aa""=""==aa

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

Çevrimiçi deneyin!

@ nimi'nin yanıtı oldukça iyi, yorum kullanmıyor. Bu daha kısa ancak bir yorum kullanıyor.

@ xnor'ın cevabı da oldukça iyi, yorum kullanıyor ve bundan daha kısa.

Python 2 , 114 bayt

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

Çevrimiçi deneyin!

Aksi takdirde Truemükemmel eşleştirilmiş dizeler için döndürür False.

(Aslında kendini doğrulayamıyor, çünkü (.)koddaki yeni satırlarla eşleşmiyor!

Bu mükemmel eşleştirilmiş bir versiyonudur:

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

bunun için bir “lazier” mükemmelleştirmesi code + '##' + f(code[::-1])120 bayt verirdi. (Yani, 6 bayt kaydedilen kodun yorum yarısı içinde daha fazla daraltılmış çift eklemek için değişkenleri vb. Yeniden adlandırın .)

re.subnre.subbir demet döndüren az bilinen bir çeşittir (new_string, number_of_substitutions_made). Regex ikame fixpoints bulmak için oldukça iyi!

Jöle , 26 24 22 bayt

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

Çevrimiçi deneyin!

Garip bir şekilde, geriye dönük kodu kullanılmayan bir bağlantıya taşımadan çalışıyor gibi görünüyor.

İade 0 girdi mükemmel eşleştirilmiş ise, 1 aksi.

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

Ataşesi , 82 bayt

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

Çevrimiçi deneyin!

Burada inanılmaz bir şey yok. Fixpointardışık çiftleri kaldıran bir sa işlevi.

Java 8, 158 156 154 bayt

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

Bir boole döndürür ( true/ false).

@Raznagul sayesinde -2 bayt .

Çevrimiçi deneyin.

Açıklama:

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