มามีฟังก์ชั่น$f$ที่รับสตริงและลบคู่ของอักขระที่เหมือนกันที่อยู่ติดกันทั้งหมด ตัวอย่างเช่น

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

โปรดทราบว่าเมื่อทับซ้อนกันสองคู่เราจะลบหนึ่งคู่เท่านั้น

เราจะเรียกสตริงที่จับคู่อย่างสมบูรณ์หากการใช้งานซ้ำ ๆ ในที่สุดก็จะทำให้สตริงว่าง ยกตัวอย่างเช่นสตริงดังกล่าวข้างต้นไม่ได้จับคู่อย่างสมบูรณ์แบบเพราะถ้าเราใช้อีกครั้งที่เรายังคงได้รับABAอย่างไรก็ตามสตริงอย่างนั้นถูกจับคู่อย่างสมบูรณ์เพราะถ้าเราใช้สามครั้งเราจะได้สตริงว่าง$abbbacc$ขอีขขคคd d จ$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 ที่พิมพ์ได้

คุณสามารถส่งออกค่าที่แตกต่างกันสองค่า: ค่าหนึ่งสำหรับกรณีที่มีการจับคู่อินพุตอย่างสมบูรณ์และอีกค่าหนึ่งสำหรับกรณีที่ไม่มี

นี่เป็นคำถามเกี่ยวกับรหัสกอล์ฟดังนั้นคำตอบจะได้คะแนนจากขนาดเป็นไบต์ของแหล่งข้อมูลด้วยจำนวนไบต์ที่น้อยลง

กรณีทดสอบ

$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 ไบต์

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

ไม่มีความคิดเห็น. ผลตอบแทนอย่างใดอย่างหนึ่งหรือTrueFalse

ลองออนไลน์!

แก้ไข: -22 ไบต์ขอบคุณ @Cat Wizard

Python 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 ไบต์

-2 ไบต์ขอบคุณที่OVS เอาต์พุต0ถ้าสตริงถูกจับคู่อย่างสมบูรณ์1จะเป็นอย่างอื่น

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

ลองออนไลน์!

ΔγʒgÉ} JJ} ĀqqĀÉgʒγΔ - โปรแกรมเต็มรูปแบบ
Δ} - จนกว่าผลลัพธ์จะไม่เปลี่ยนแปลงอีกต่อไป:
 γʒ} - แยกสตริงออกเป็นส่วน ๆ ของตัวอักษรและตัวกรองเท่ากันโดย:
   gÉ - ยาวแปลกไหม
      JJ - และหลังจากกรองแล้วให้เข้าร่วมส่วนต่าง ๆ ด้วยกัน แต่ทำสิ่งนี้
                     สองครั้งเพื่อบันทึก 2 ไบต์เช่นเดียวกับในรุ่นก่อนหน้า
         Ā - ตรวจสอบว่าผลลัพธ์ว่างเปล่า
          q - การดำเนินการยุติ (ออก) ส่วนที่เหลือของรหัสจะถูกละเว้น
           คำถาม - จำลองส่วนที่ไม่ตรงกันเพื่อช่วยในการจัดวางแหล่งที่มา

รุ่นก่อนหน้า

อันนี้ต้องอาศัยพฤติกรรมที่ไม่ได้กำหนด (ดังนั้นจึงไม่มี "รหัสตาย") และผลลัพธ์[['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 .
      . ; .
      . ; !
      ^ ^ !

คำอธิบาย

อักขระส่วนใหญ่เป็นฟิลเลอร์ที่จำเป็นในการจับคู่รหัสอย่างสมบูรณ์ .เราได้รับการแทนที่ด้วย(ไม่มี op)

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

สิ่งนี้สามารถแบ่งออกเป็นสามขั้นตอน:

• ตรวจสอบกับสตริงว่าง (ซ้ายiและ?)
• วนซ้ำตัวอักษรลงบนสแต็คและซ้ำ popping (ทุกอย่างที่ด้านล่างและขวา)
• ตรวจสอบว่าสแต็กว่างเปล่า (สิ่งที่อยู่ด้านบน)

V , 20 , 18 ไบต์

òóˆ±òø‚

::‚øò±ˆóò

ลองออนไลน์!

hexdump:

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

เอาต์พุต 0 สำหรับความจริง, 1 สำหรับความเท็จ ขอบคุณ nmjcman101 สำหรับการบันทึกทางอ้อม 2 ไบต์

ò        ò        " 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 ไบต์

ตรรกะที่เข้มงวดมากขึ้นและบางความคิดเห็นไบต์ golfed โดย @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 28ไบต์

+`(.)\1

C`^$

$^`C1\).(`+

ลองออนไลน์!

ผลลัพธ์`C1\).(`+0`C1\).(`+สำหรับการเป็นเท็จและ`C1\).(`+1`C1\).(`+สำหรับกรณีที่เป็นความจริง

Brain-Flak , 228 200 ไบต์

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

ลองออนไลน์!

นี่เป็นข้อพิสูจน์แนวคิด มันอาจจะสั้นกว่านี้ ไม่ได้ใช้ความคิดเห็นใด ๆ

เอาต์พุต0,0ถ้าอินพุตถูกจับคู่อย่างสมบูรณ์และ0,1ถ้าอินพุตไม่

sed 4.2.2 , 34 ไบต์

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

ลองออนไลน์!

สตริงที่จับคู่ให้เอาท์พุทที่ว่างเปล่าให้คนที่ไม่ได้คู่ให้ ct:

รุ่น palindromic เล็กน้อยก็คือที่ :;ss(.)\1ss;t;/./cc/./;t;1\).(;:32 โซลูชันเดิมคือ:;ss((..??\??))\1ss1;t;;/./cc/./t:(เปลี่ยนเนื่องจากปัจจุบันมีการละเมิดcน้อยกว่าแก้ไข: ใช่ตอนนี้มีเพียง 1 ตัวอักษรหลังจากc: D)

(โปรดทราบว่า;เป็นตัวคั่นคำสั่ง)

: ประกาศป้ายกำกับที่ว่างเปล่า

:t ประกาศฉลาก t

ss((..??\??))\1ss1เป็นการทดแทนใน sed คุณสามารถเปลี่ยน delimiter เป็นการทดแทนได้และนี่คือสิ่งที่ฉันทำโดยการเปลี่ยนเป็นsดังนั้นสิ่งนี้จะแทนที่ตัวแรก (ดังที่แสดงโดย1ตอนท้าย)

• การแข่งขันของ ((..??\??))\1

  • . ตัวละครใด ๆ
  • .?? ตามด้วยอักขระตัวเลือกเพิ่มเติม
  • \?? และตัวเลือก ?
  • ตามด้วยสิ่งเดียวกันข้างๆมัน

• ด้วยอะไร

ตอนนี้การทดแทนนี้ถูกจับคู่กับตัวเองดังนั้น;s ก่อนและหลังมันก็ถูกยกเลิกเช่นกัน

t และวนกลับไปที่ป้ายกำกับจนกว่าจะไม่มีการทดแทนที่ประสบความสำเร็จอีก

/..?/if .(wildcard) ตามด้วย.?อักขระตัวเลือกที่ตรงกัน

• cc เปลี่ยนบัฟเฟอร์เป็น c

Brain-Flak , 112 110 108 ไบต์

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

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

ลองออนไลน์!

นี่คือคำตอบของฉันจากวงเล็บมีการจับคู่หรือไม่? .

พยายามที่จะไม่ใช้ความคิดเห็น แต่ติดขัดในการพยายามทำให้ป๊อป nilads ( {}) จับคู่กัน ปัญหาอยู่ในวิธีที่ง่ายที่สุดในการจับคู่วงเล็บคือการล้อมรอบในอีกประเภทเดียวกัน ขณะนี้เป็นเรื่องง่ายสำหรับ nilads อื่น ๆ{...}monad สร้างลูป ในการออกจากลูปคุณจะต้องกด 0 แต่เมื่อคุณออกจากลูปคุณจะต้องป๊อป 0 ซึ่งประกอบปัญหา

วิธีแก้ปัญหาที่จับคู่ 66 ไบต์คือ:

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

ลองออนไลน์!

เอาท์พุท1หรือ1,0ถ้าอินพุทเป็นการจับคู่ที่สมบูรณ์แบบ0,0ถ้าไม่

ไม่มีรุ่นความคิดเห็น 156 ไบต์

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

ลองออนไลน์!

ในขณะที่ Cat Wizard ชี้ให้เห็นคำตอบแรกไม่สามารถใช้ได้กับล่ามทุกคนเนื่องจากไม่ได้#แสดงความคิดเห็นทั้งหมด รุ่นนี้ไม่มีความคิดเห็น

Japt 24 24ไบต์

ผลลัพธ์falseสำหรับความจริงและtrueเพื่อความเท็จ

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

ลองมัน

Brain-Flakขนาด 96 ไบต์

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

ลองออนไลน์!

ไม่มีผลใด ๆ หากอินพุตถูกจับคู่อย่างสมบูรณ์และเป็น0อย่างอื่น

รุ่นที่ไม่ได้จับคู่อย่างสมบูรณ์แบบ (ดั้งเดิม):

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

ลองออนไลน์!

Haskell , 66 ไบต์

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

ลองออนไลน์!

ตัวช่วยสร้างแมวบันทึก 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 ไบต์นานก่อนที่คำอธิบายจะเริ่มขึ้นตอนนี้มันเต้นจาวา

เอาต์พุตTrueสำหรับสตริงที่สมดุลอย่างสมบูรณ์และFalseอื่น ๆ

เพื่อความพึงพอใจอันยิ่งใหญ่ของฉันนี่เป็นการตีรุ่น palindromize ที่น่าเบื่อด้วย2ไบต์เพื่อป้องกันผลลัพธ์ที่พิมพ์ออกมาสองครั้ง ฉันยังมุ่งที่จะมีรหัสตายตัวน้อยที่สุดเท่าที่จะทำได้อย่างไรก็ตามยังมีบางส่วนที่ถูกคอมเม้นต์และรหัสออกด้วยรหัสข้อผิดพลาด1หลังจากพิมพ์ค่าที่ถูกต้อง

NB : ข้อผิดพลาดกับ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$ระบุจำนวนตัวอักษรถัดไปที่เราต้องการเก็บ สำหรับคู่ที่เรียบง่ายเราจะลบพวกเขาทั้งหมด (ให้ผลเป็น0ของตัวละครถัดไป) สำหรับตัวอักษรตัวเดียวที่เราปล่อยให้พวกเขาแตะต้องหรือให้ผล1ของพวกเขาและสำหรับกลุ่มที่$x > 2$, พวกเราต้องการ $x - 2$ของตัวละคร เพื่อที่จะสร้าง$x$ของตัวละครเราทำซ้ำตัวละครด้วย*และฟังก์ชั่นส่งกลับองค์ประกอบบนสุดของสแต็กโดยธรรมชาติ: สตริงซ้ำ

หลังจาก $g(s)$ ถูกแมปผ่านแต่ละกลุ่ม $s$BFเราอาร์เรย์แดงไปยังกองที่จะได้รับผลแต่ละบุคคลที่มี ในที่สุด^แฟล็กที่นิยามฟังก์ชัน ( D,ff,@^^,) จะบอกให้ฟังก์ชันส่งคืนเชื่อมสตริงในสแต็กและส่งคืนเป็นสตริงเดียว สำหรับคู่ซึ่งให้สตริงว่างจาก$g$สิ่งนี้จะลบมันออกโดยที่สตริงว่างตัดกับสตริงใด ๆ $r$ ผลลัพธ์ใน $r$. อะไรก็ตามหลังจากทั้งสอง;;คือความคิดเห็นและจะถูกเพิกเฉย

สองบรรทัดแรกกำหนดฟังก์ชันทั้งสอง $\mathit{ff}$ และ $g$แต่ไม่ต้องดำเนินการ $\mathit{ff}$เพียงแค่ จากนั้นเราก็นำเข้าและเก็บไว้ในตัวแปรแรกของเรา 4 ตัว ตัวแปรเหล่านั้นคือ:

• $\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$ โดยค่าเริ่มต้น แต่สามารถเปลี่ยนแปลงได้ด้วย `คำสั่ง เมื่อเปลี่ยนตัวแปรที่ใช้งานเป็นสิ่งสำคัญที่จะต้องทราบว่าตัวแปรแอคทีฟใหม่ไม่จำเป็นต้องมีอยู่ก่อนและจะถูกกำหนดเป็น 0 โดยอัตโนมัติ

ดังนั้นหลังจากกำหนด $\mathit{ff}$ และ $g$เรากำหนดอินพุตให้ $\mathit{xx}$xx:?กับ จากนั้นเราต้องจัดการกับเงื่อนไขลูปของเราเล็กน้อย อันดับแรกเราต้องการตรวจสอบให้แน่ใจว่าเราป้อนขณะที่ลูปเว้นแต่$\mathit{xx}$มันว่างเปล่า. ดังนั้นเราจึงกำหนดค่าความจริงให้กับ$\mathit{aa}$ด้วยaa:1ค่าที่สั้นที่สุดเช่นนี้$1$. จากนั้นเราจะกำหนดความจริงของ$\mathit{xx}$ ไปยัง $\mathit{bb}$ ด้วยสองบรรทัด

`bb
Bxx

ซึ่งก่อนอื่นทำ $\mathit{bb}$ ตัวแปร active จากนั้นรันคำสั่ง boolean $\mathit{xx}$. ทางเลือกที่เกี่ยวข้องของ$\mathit{aa} := 1$ และ $\mathit{bb} := \neg \neg \mathit{xx}$ เรื่องตามที่จะแสดงในภายหลัง

จากนั้นเราเข้าไปในห่วงของเราในขณะที่:

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

ห่วงในขณะที่เป็นโครงสร้างใน 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}$:

• 1) อินพุตว่างเปล่า ในกรณีนี้ลูปไม่ทำงาน$\mathit{aa} = 1$ และ $\mathit{bb} = \mathrm{False}$. ผลลัพธ์ที่ถูกต้องคือ$\mathrm{False}$.
• 2) อินพุตมีความสมดุลอย่างสมบูรณ์แบบ ถ้าเป็นเช่นนั้นลูปจะวิ่ง$\mathit{aa} = \mathrm{True}$ และ $\mathit{bb} = \mathrm{False}$. ผลลัพธ์ที่ถูกต้องคือ$\mathrm{False}$
• 3) อินพุตไม่สมดุลอย่างสมบูรณ์ ถ้าเป็นเช่นนั้นลูปจะวิ่ง$\mathit{aa} = \mathrm{False}$ และ $\mathit{bb} = \mathrm{True}$. ผลลัพธ์ที่ถูกต้องคือ$\mathrm{True}$

อย่างที่เห็น, $\mathit{bb}$เท่ากับเอาท์พุทที่คาดหวัง (แม้ว่าจะกลับจากคำตอบเชิงตรรกะ ) ดังนั้นเราก็แค่เอาท์พุท ไบต์สุดท้ายที่ช่วยเราเอาชนะ Java มาจากความจริงที่ว่า$\mathit{bb}$ เป็นตัวแปรที่ใช้งานอยู่ดังนั้นสามารถตัดออกจากการโต้แย้งทำให้เราออกผลลัพธ์เช่นกัน $\mathrm{True}$ หรือ $\mathrm{False}$ขึ้นอยู่กับว่าอินพุตนั้นมีความสมดุลอย่างสมบูรณ์หรือไม่

JavaScript (ES6), 76 ไบต์

ส่งคืนบูลีน

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

ลองออนไลน์!

แนะนำโดย @Shaggy: 58 ไบต์โดยส่งคืนสตริงว่างสำหรับการจับคู่หรือการโยนข้อผิดพลาดอย่างสมบูรณ์

ภาษา Wolfram (Mathematica) , 70 64 ไบต์

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

ลองออนไลน์!

ไม่มีความคิดเห็น 92 ไบต์

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

ลองออนไลน์!

Lua , 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

ลองออนไลน์!

ในขณะที่มันเป็นทางออกที่ยาวชะมัด แต่มันใช้ประโยชน์จากนิสัยแปลก ๆ ของ Lua นี่เป็นอัลกอริทึมกองกำลังเดรัจฉานขนาดเล็ก โปรแกรมนี้มีความซับซ้อนเนื่องจากรูปแบบของ Lua ไม่อนุญาตให้แทนที่คู่และ regex ไม่ได้ถูกสร้างขึ้น

คำอธิบาย:

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 แต่ไม่มีการตรวจสอบอย่างชัดเจนสำหรับสตริงว่าง

Haskell , 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นั้นยอดเยี่ยมเช่นกันมันใช้ความคิดเห็นและสั้นกว่าอันนี้

Python 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.subnเป็นตัวแปรที่รู้จักกันน้อยของre.subผลตอบแทนที่ (new_string, number_of_substitutions_made)tuple มันค่อนข้างดีสำหรับการค้นหาจุดทดแทน regex!

เยลลี่ , 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 ซึ่งจะลบคู่ที่ต่อเนื่องกัน

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

-2 ไบต์ขอบคุณที่@raznagul

ลองออนไลน์

คำอธิบาย:

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