มีอยู่ไม่กี่คำถามในเว็บไซต์นี้เกี่ยวกับความสมดุลวงเล็บและตรวจสอบว่าวงเล็บมีความสมดุล ฉันเสนอเวลาที่จะใช้วงเล็บที่สมดุลเหล่านี้สำหรับบางสิ่ง!

ในคณิตศาสตร์และการเขียนโปรแกรมวงเล็บเป็นเหมือนฟองสบู่การแยกทุกอย่างออกจากกันในรูปแบบภายนอกเพื่อให้สิ่งที่อยู่ภายในสามารถทำสิ่งต่าง ๆ ได้โดยสันติ อย่างไรก็ตามสตริงของวงเล็บเป็นหนึ่งมิติในขณะที่ฟองอากาศมักจะมีอย่างน้อยสองมิติ นั่นหมายความว่าฟองอากาศสามารถเคลื่อนที่ไปมาได้อย่างอิสระตราบใดที่พวกเขาไม่เคยสัมผัสกันหรือข้ามระหว่างด้านในและด้านนอกของฟองอื่น ๆ

ท้าทาย

การป้อนข้อมูลที่เป็นสตริงของวงเล็บตรงกันชนิดเดียวทั้งรอบ(), ตาราง[]หยิกหรือมุม{} <>มันขึ้นอยู่กับคุณว่าคุณต้องการให้โปรแกรมของคุณรับและโปรแกรมที่ยอมรับเฉพาะวงเล็บชนิดเดียวเท่านั้น (โบนัสจินตภาพหากโปรแกรมของคุณสามารถจัดการกับพวกเขาใด ๆ คะแนนโบนัสขนาดใหญ่ในจินตนาการถ้ามันสามารถจัดการกับพวกเขาทั้งหมดในการป้อนข้อมูลเดียวกัน.) การป้อนข้อมูลไม่สามารถมีอะไรระหว่างวงเล็บแม้จะอนุญาต whitespaces ต่อท้าย

เอาต์พุตคือการจัดระเบียบใหม่ที่เป็นไปได้ทั้งหมด (ตามลำดับโดยพลการและรวมถึงอินพุตดั้งเดิม) ของวงเล็บเหล่านั้นที่ให้การกำหนดค่าแบบเดียวกันของฟองอากาศโดยไม่มีสองสตริงที่เหมือนกัน นั่นหมายความว่าเมื่อมีการป้อนข้อมูล()()เอาท์พุทก็เป็นเพียงแค่()()แม้ว่ามันจะมีสองฟองอากาศที่สามารถสลับตำแหน่งได้ สำหรับโบนัสจำนวนมหาศาลจำนวนนับไม่ถ้วน{}[]()นำไปสู่ผลลัพธ์ขององค์ประกอบ / สตริง / บรรทัด 6 รายการที่แตกต่างกัน

การกำหนดค่าของฟองสองแบบคือ "เหมือนกัน" ถ้าคุณสามารถทำให้เข้าด้วยกันโดยการย้ายฟองรอบ ๆ โดยไม่ปล่อยให้ฟองใด ๆ ผ่านจากภายในอีกฟองหนึ่งไปยังด้านนอกหรือจากภายนอกสู่ภายใน หากคุณเปรียบวงเล็บที่ซ้อนกันกับต้นไม้ (คู่ที่ตรงกันแต่ละคู่เป็นหนึ่งโหนดและทุกคู่ที่ตรงกันภายในเป็นโหนดย่อยและแต่ละคู่ที่ตรงกันภายในนั้นมีโหนดย่อยของอีกครั้งและอื่น ๆ ) โดยที่โหนดย่อยของโหนดที่กำหนดใด ๆ จากนั้นการกำหนดค่าเดียวของบับเบิลคือแผนผังที่ไม่มีการเรียงลำดับโหนด

รูปแบบเอาต์พุตที่สมเหตุสมผลใด ๆ จะทำเช่นส่งคืนรายการสตริงหรือรายการของอักขระเดี่ยวหรือสตริงเดี่ยวที่มีช่องว่างบางชนิดหรือพิมพ์ไปยังstdoutหรือstderrด้วยอักขระช่องว่างที่มองเห็นได้บางรูปแบบ (ขึ้นบรรทัดใหม่หรือช่องว่างทั่วไป) ระหว่าง การปรับโครงสร้างแต่ละครั้ง

ช่องว่างต่อท้ายสำหรับแต่ละการจัดระเบียบใหม่และการติดตามและนำหน้ารายการบรรทัดใหม่ / รายการว่างเปล่าก่อนและหลังการส่งออกจริงที่ได้รับอนุญาต คุณควรใช้วงเล็บชนิดเดียวกันในเอาต์พุตของคุณตามที่คุณยอมรับในอินพุตของคุณ นอกเหนือจากเครื่องหมายวงเล็บบรรทัดใหม่และช่องว่างตามที่ระบุไว้ที่นี่และตัวคั่นใดก็ตามที่คุณใช้ไม่ควรพิมพ์อะไร (รวมถึงอักขระที่มองไม่เห็น / ความกว้างเป็นศูนย์)

คะแนนคือจำนวนไบต์ในโค้ด จำนวนต่ำสุดสำหรับแต่ละภาษาที่ชนะ คุณอาจสังเกตว่าคุณได้รับโบนัสจินตภาพไม่ว่าจะเป็นธรรมดาหรือใหญ่ แต่จะไม่ส่งผลกระทบต่อคะแนนของคุณ โบนัสที่เกิดขึ้นจริงนั้นยากที่จะรักษาสมดุล

ตัวอย่างอินพุต - เอาท์พุต

ตัวอย่างที่ 1:

การป้อนข้อมูล:

()(())

เอาท์พุท:

()(())
(())()

ตัวอย่างที่ 2:

การป้อนข้อมูล:

(()())()()

เอาท์พุท:

(()())()()
()(()())()
()()(()())

ตัวอย่างที่ 3:

การป้อนข้อมูล:

(()(()))()

เอาท์พุท:

((())())()
()((())())
(()(()))()
()(()(()))

CJam , 18 ไบต์

{~{_{{B}%e!}&}:B~}

ลองออนไลน์!

-2 ขอบคุณที่ธุรกิจแมว

[]ได้รับข้อมูลเป็นสตริงที่มีเพียง ส่งคืนรายการการเรียงสับเปลี่ยน (รายการว่างเหมือนกับสตริงว่างใน CJam ดังนั้น[]คุณจะได้รับแทน"")

Haskell , 227 210 208 205 ไบต์

import Data.List
l=last
a!x=init a++[l a++[x]]
h[]=[""]
h(x:y)=["("++z++")"++t|z<-v x,t<-h y]
g(a,r)x|x=='('=(a+1,l$(r++h[]):[r!x|a>0])|1>0=(a-1,l$r:[r!x|a>1])
v s=nub$h=<<(permutations.snd$foldl g(0,[])s)

ลองออนไลน์!

อันนี้มันยาก!

Golfed เล็กน้อย

บันทึกสองไบต์ต้องขอบคุณ Laikoni

บันทึกสองไบต์ด้วย Bruce Forte

ฉันไม่แน่ใจว่าวิธีนี้ใช้ได้ในทุกกรณี คำอธิบายบางอย่าง:

• a!xเพิ่ม String xเข้ากับรายการสุดท้ายของ String in a(a is of type [[String]])

• snd$foldl(\(a,r)x->if x=='('then(a+1,last$(r++[[]]):[r!x|a>0])else(a-1,last$r:[r!x|a>1])ใช้เงื่อนไขที่สั้นกว่าเพื่อแสดงความคิดง่ายๆ: แบ่งสตริงบนรูท )( s เช่นให้"(()(()))()"["()(())", ""]

• เราจำเป็นต้องประมวลผลแต่ละส่วนของการแยกจากนั้นเพื่อรวบรวมและเข้าร่วมสตริงทั้งหมดเพื่อให้ได้ผลลัพธ์ที่ถูกต้อง:

  1. hประมวลผลรายการชิ้นส่วน: มันใช้vกับส่วนแรกและรวมผลลัพธ์กับกระบวนการของส่วนที่เหลือ

  2. v รวมผลลัพธ์สำหรับการเปลี่ยนรูปแต่ละส่วนและลบรายการที่ซ้ำกัน

ในการเพิ่มมุมมองที่กว้างขึ้น: คุณมีต้นไม้ (ไม่ใช่ไบนารี) โดยมีโหนดว่าง ()ทิ้งไว้ คุณต้องสร้างการเรียงสับเปลี่ยนทั้งหมดของแต่ละโหนดสำหรับแต่ละโหนด แต่คุณไม่สามารถแยกสาขาจากโหนดหนึ่งและวางบนโหนดอื่น ฉันทำการค้นหาแบบเจาะลึกก่อน

Python 2 353 350 331 ไบต์

s=input()
f=lambda i,t=0:i+1if t<0else f(i+1,t-1)if"("<s[i+1]else f(i+1,t+1)
c=[(x,f(x))for x in range(len(s))if")">s[x]]
p=lambda l:[[]]if len(l)<1else[x for y in p(l[1:])for x in[y[:i]+[l[0]]+y[i:]for i in range(len(y)+1)]]
print[''.join(x)for x in p([s[c[x][0]:c[x][1]]for x in range(len(c))if all(c[x][1]>y[1]for y in c[:x])])]

รับสตริง()เป็นอินพุตและพิมพ์ผลลัพธ์

ลองที่นี่!

ฉันหลีกเลี่ยงการใช้itertools.permutationsด้วยความช่วยเหลือจากคำตอบของเปาโลสำหรับคำถามนี้

ขอบคุณBusiness Catสำหรับการค้นหา 3 ไบต์และขอขอบคุณMr. Xcoder 19 ไบต์ที่เหลือเชื่อ!

คำอธิบาย

1. สร้างรายการของ tuples ของดัชนีของแต่ละ()คู่ในสายป้อน
2. วางสิ่งอันดับใด ๆ จากรายการที่ล้อมรอบด้วย()คู่อื่น
3. ฝานสตริงที่ดัชนีของสิ่งอันดับที่เหลือ
4. ทำรายการการเปลี่ยนลำดับของแต่ละรายการ
5. เข้าร่วมรายการด้วยบรรทัดใหม่สำหรับการพิมพ์

JavaScript (Firefox 30-57), 222 ไบต์

s=>(g=a=>a+a?[for(x of g(a[0]))for(y of a.keys())for(z of g(a.slice(1)))(z.splice(y,0,x),z)]:[a])(eval(`[${s.replace(/]\[/g,`],[`)}]`)).map(g=a=>`[`+a.map(g).join``+`]`).sort().filter(s=>t<(t=s),t=``).map(s=>s.slice(1,-1))

รับ[]สาย คำอธิบาย:

s=>(                                Inner function to permute an array
 g=a=>a+a?[                         If array is not empty
  for(x of g(a[0]))                 Permute the first element of the array
  for(y of a.keys())                Generate a list of insertion points
  for(z of g(a.slice(1)))           Permute the rest of the array
  (z.splice(y,0,x),z)]:             Make all possible permutations
  [a]                               Otherwise return a list of an empty array
)(eval(`[${                         Convert the string to a nested array
   s.replace(/]\[/g,`],[`)}]`)      ... inserting commas where necessary
).map(                              Process the results
 g=a=>`[`+a.map(g).join``+`]`       Recursively convert back to string
).sort().filter(s=>t<(t=s),t=``     Check for duplicates
).map(s=>s.slice(1,-1))             Remove outer `[]`s

Mathematica, 337 ไบต์

ที่จะไม่รับคะแนน code-golf แต่เพื่อแสดงการใช้งานPermutationsและDistributeในปัญหานี้ แม้ว่าจะมีวิธีการที่ดีกว่าก็ตาม

( seq: ลำดับ, alt: ทางเลือก)

SetAttributes[alt, {Flat, OneIdentity}]
StringTake[
  StringReplace[ToString[
    ToExpression["{" <> StringReplace[#, "}{" -> "},{"] <> "}"]
        /. List -> Permutations@*seq
       /. List -> alt
      /. seq -> (Distribute[seq@##, alt] &)
     /. {seq -> List, alt -> Alternatives}],
   {", " -> "", "} | {" -> "\n"}],
  {2, -2}] &

ใช้การป้อนข้อมูลเป็นสตริงโดยใช้วงเล็บปีกกาและ{ }เอาต์พุตสตริงหลายบรรทัด