कोष्ठक का बुलबुला!

Question

वहाँ हैं कुछ सवाल इस साइट पर कोष्ठक संतुलन, और यह जांच करें कि क्या कोष्ठक संतुलित कर रहे हैं के बारे में। मैं प्रस्ताव करता हूं कि अब उन संतुलित कोष्ठकों का उपयोग किसी चीज़ के लिए करने का समय है!

गणित और प्रोग्रामिंग में, कोष्ठक बुलबुले की तरह होते हैं, हर चीज़ को अंदर से बाहर अलग कर देते हैं ताकि जो भी अंदर हो वह अपनी बात शांति से कर सके और जो कुछ भी बाहर है वह केवल एक वस्तु को देख सके। हालांकि, ब्रैकेट्स की एक स्ट्रिंग एक आयामी है, जबकि बुलबुले आमतौर पर कम से कम दो आयामी होते हैं। इसका मतलब है कि बुलबुले एक दूसरे के आसपास तब तक घूमने के लिए स्वतंत्र हैं जब तक वे एक-दूसरे को स्पर्श नहीं करते हैं या किसी अन्य बुलबुले के अंदर और बाहर के बीच पार नहीं करते हैं।

चुनौती

इनपुट एक प्रकार के मिलान किए गए ब्रैकेट का एक स्ट्रिंग है, या तो गोल (), चौकोर [], घुंघराले {}या कोण <>। यह आपके ऊपर है कि आप किस तरह का अपना प्रोग्राम स्वीकार करना चाहते हैं, और एक ऐसा प्रोग्राम जो केवल एक ही तरह के ब्रैकेट को स्वीकार करता है। (काल्पनिक बोनस यदि आपका प्रोग्राम उनमें से किसी को भी संभाल सकता है, तो बड़े पैमाने पर काल्पनिक बोनस अंक यदि यह एक ही इनपुट में उन सभी को संभाल सकता है।) इनपुट में कोष्ठक के बीच कुछ भी नहीं हो सकता है, हालांकि अनुगामी व्हाट्सएप की अनुमति है।

आउटपुट उन सभी कोष्ठकों के सभी संभावित पुनर्गठन (मनमाने क्रम में, और मूल इनपुट सहित) है जो बुलबुले के समान विन्यास को उत्पन्न करते हैं, जिसमें दो समान तार नहीं होते हैं। इसका मतलब है कि इनपुट के साथ ()(), आउटपुट भी बस है ()(), भले ही यह तकनीकी रूप से दो बुलबुले हैं जो स्थानों को स्वैप कर सकते हैं। बड़े पैमाने पर काल्पनिक बोनस के लिए, {}[]()निश्चित रूप से 6 अलग-अलग तत्वों / स्ट्रिंग्स / लाइनों के उत्पादन के लिए इनपुट का नेतृत्व किया जाएगा।

बुलबुले के दो विन्यास "समान" हैं यदि आप बुलबुले को एक दूसरे के चारों ओर ले जाकर दूसरे में बना सकते हैं, बिना किसी बुलबुले को दूसरे बुलबुले के अंदर से बाहर तक, या बाहर से अंदर तक। यदि आप नेस्टेड कोष्ठकों को पेड़ों की तरह पसंद करते हैं (प्रत्येक मिलान की गई जोड़ी एक नोड है, और प्रत्येक मिलान की गई जोड़ी एक सबनोड है, और प्रत्येक मिलान की गई जोड़ी फिर से उन लोगों का उप-कोड है, और इसी तरह) जहां किसी दिए गए नोड के उप-नोड्स का आदेश दिया जाता है। , फिर बुलबुले का एक एकल विन्यास एक पेड़ है जहां नोड्स अव्यवस्थित हैं।

कोई भी उचित आउटपुट फॉर्मेट करेगा, जैसे स्ट्रिंग्स की सूची या एकल वर्णों की सूची की सूची या किसी प्रकार के व्हाट्सएप के साथ एक सिंगल स्ट्रिंग, या प्रिंटिंग के लिए stdoutया stderrकिसी प्रकार के दृश्यमान व्हाट्सएप चरित्र के साथ (सबसे सामान्य रूप से नई पंक्ति या स्थान)। प्रत्येक पुनर्गठन।

प्रत्येक पुनर्गठन और अनुगामी के लिए रिक्त स्थान और वास्तविक उत्पादन से पहले और बाद में newlines / खाली सूची तत्वों को आगे बढ़ाने की अनुमति है। आपको अपने आउटपुट में उसी तरह के ब्रैकेट का उपयोग करना चाहिए जैसा कि आप अपने इनपुट में स्वीकार करते हैं। यहां बताए गए कोष्ठक, नई रेखाओं और रिक्त स्थान के अलावा, और जो भी विभाजक आप उपयोग करते हैं, कुछ भी मुद्रित नहीं होना चाहिए (अदृश्य / शून्य-चौड़ाई वर्ण सहित)।

कोड में स्कोर बाइट्स की संख्या है; प्रत्येक भाषा की जीत के लिए सबसे कम गिनती। आप ध्यान दें कि क्या आपको नियमित या बड़े पैमाने पर काल्पनिक बोनस मिलता है, लेकिन यह आपके स्कोर को प्रभावित नहीं करता है। वास्तविक बोनस सही संतुलन के लिए बहुत कठिन हैं।

इनपुट-आउटपुट उदाहरण

उदाहरण 1:

इनपुट:

()(())

आउटपुट:

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

उदाहरण 2:

इनपुट:

(()())()()

आउटपुट:

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

उदाहरण 3:

इनपुट:

(()(()))()

आउटपुट:

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

Comments

हम ((()))उदाहरण 1 में क्यों नहीं मिल सकते हैं ? या ()()()? ऐसा लगता है कि आप प्रत्येक इनपुट के लिए क्रमपरिवर्तन याद कर रहे हैं।

— गेहूं जादूगर

@WheatWizard बुलबुले के समान विन्यास नहीं देगा: दो खाली बुलबुले के साथ एक बड़ा बुलबुला।

— आर्थर

@WheatWizard जहाँ तक मैं समझता हूँ, आप एक बुलबुले को दूसरे बुलबुले के अंदर से बाहर, या इसके विपरीत नहीं ले जा सकते।

— ग्रेजोर्ज़ पुलावस्की

@WheatWizard मैंने एक छोटा स्पष्टीकरण जोड़ा।

— आर्थर

Btw, PPCG में आपका स्वागत है! अच्छी पहली चुनौती!

— श्री Xcoder

Answer 1

सीजाम , 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-2 बिजनेस कैट को धन्यवाद ।

केवल एक स्ट्रिंग युक्त इनपुट प्राप्त करता है []। क्रमपरिवर्तन की सूची लौटाता है (खाली सूची CJam में खाली तार के समान होती है, इसलिए []आपको मिलने के बजाय "")।

Comments

[][]सिर्फ उत्पादन के लिए क्यों है ""? - क्या इनपुट अतिरिक्त सेट में संलग्न होना चाहिए []? यदि ऐसा है तो वहाँ []क्या (शायद?) के आसपास का एक अतिरिक्त सेट है, उदाहरण के लिए आउटपुट है? साथ ही प्रश्न कहता है कि "आपको अपने आउटपुट में उसी तरह के ब्रैकेट का उपयोग करना चाहिए जैसा कि आप अपने इनपुट में स्वीकार करते हैं। ब्रैकेट्स के अलावा, यहां बताए गए अनुसार नई लाइनें और रिक्त स्थान, और जो भी विभाजक आप उपयोग करते हैं, कुछ भी मुद्रित नहीं होना चाहिए", इसलिए मैं ' मी निश्चित नहीं है []और ""स्वीकार्य है।

— जोनाथन एलन

@JonathanAllan हाँ मुझे लगता है कि आपको [][]एक अतिरिक्त जोड़ी बनाने की आवश्यकता है []। दूसरों के लिए मुझे यकीन नहीं है कि वे अमान्य हैं।

— आउटगॉल्फ

मुझे लगता है कि आप _{{B}%e!}&इसके बजाय_!!{{B}%e!}*

— बिजनेस कैट

@BusinessCat &शॉर्ट-सर्किट या कुछ और करता है?

— को एग्री आउटफोलर

&ब्लॉक तभी चलता है जब अन्य मूल्य सत्य है

— बिजनेस कैट

Answer 2

हास्केल , 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)

इसे ऑनलाइन आज़माएं!

यह एक कठिन था!

थोड़ा-थोड़ा घूमे

लाकोनी के लिए धन्यवाद, दो बाइट्स बचाए

ब्रूस फोर्ट के लिए दो बाइट्स सहेजें

मुझे यकीन नहीं है कि यह हर मामले में काम करता है। कुछ स्पष्टीकरण:

• a!xस्ट्रिंग xको अंतिम सूची में जोड़ें a(एक प्रकार का [[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])सरल विचार व्यक्त करने के लिए छोटी सशर्त का उपयोग करता है: मूल पर स्ट्रिंग को विभाजित करें )(। जैसे "(()(()))()"देता है ["()(())", ""]।

• हमें विभाजन के प्रत्येक भाग को संसाधित करने की आवश्यकता है, फिर सही आउटपुट प्राप्त करने के लिए सभी तारों को इकट्ठा करने और शामिल करने के लिए:

  1. hभागों की एक सूची vसंसाधित करता है : यह पहले भाग पर लागू होता है और शेष भागों की प्रक्रिया के लिए परिणाम को जोड़ती है।

  2. v भागों के प्रत्येक क्रमपरिवर्तन के लिए परिणामों को एकत्रित करता है, और डुप्लिकेट को हटाता है।

एक व्यापक दृश्य जोड़ने के लिए: आपके पास मूल रूप से एक पेड़ है (बाइनरी नहीं) खाली नोड्स के साथ। छुट्टी है ()। आपको प्रत्येक नोड के लिए शाखाओं के सभी क्रमपरिवर्तन का उत्पादन करना होगा, लेकिन आप एक नोड से एक शाखा नहीं ले सकते हैं और इसे दूसरे नोड पर डाल सकते हैं। मैंने एक तरह की गहराई में पहली खोज की।

Comments

आप कोष्ठकों को चारों ओर छोड़ सकते हैं init a।

— लैकोनी

Answer 3

अजगर 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से मदद लेने से बचता हूं ।

3 बाइट्स खोजने के लिए बिजनेस कैट को धन्यवाद, और अविश्वसनीय 19 बाइट्स के लिए मिस्टर एक्सकोडर को धन्यवाद !

व्याख्या

1. ()इनपुट स्ट्रिंग में प्रत्येक जोड़ी के सूचकांकों के tuples की सूची बनाएं ।
2. सूची से किसी भी टुपल्स को छोड़ें जो दूसरी ()जोड़ी से घिरे हैं ।
3. शेष ट्यूपल्स के सूचकांकों पर स्ट्रिंग स्लाइस करें।
4. स्लाइस की सूची के प्रत्येक क्रमांकन की एक सूची बनाएं।
5. मुद्रण के लिए एक नई लाइन के साथ सूची में शामिल हों।

Comments

मैं कुछ बाइट्स देखता हूं जिन्हें मुंडाया जा सकता है। आपके पास कुछ व्हाट्सएप हैं जिन्हें हटाया जा सकता है, अर्थात् बाद में printऔर जैसे स्पॉट i+1 if(हो सकता है i+1if)। इसके अलावा, आपके पास एक जगह पर y[0:i], आप

— बिजनेस कैट

धन्यवाद, @BusinessCat! मेरी आईडीई उनमें से कुछ पर शिकायत करती है, इसलिए मैं अभी भी कुछ कोड गोल्फ ट्रिक्स सीख रहा हूं।

— विलायती

व्हाट्सएप को हटाने के लिए कुछ शर्तों को फिर से व्यवस्थित करके 342 बाइट्स (-8 बाइट्स) ।

— श्री एक्सकोडर

समानता की जाँच पर लेक्सोग्राफिक तुलना का उपयोग करके 340 बाइट्स (-10 बाइट्स) ।

— श्री एक्सकोडर

331 बाइट्स (-19 बाइट्स) क्योंकि चुनौती स्ट्रिंग्स की सूची को वापस करने की अनुमति देती है। yay, हमने Mathematica :-)

— Mr. Xcoder

Answer 4

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 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

Answer 5

गणितज्ञ, 337 बाइट्स

नहीं कोड गोल्फ अंक प्राप्त करने के लिए, लेकिन के उपयोग को दिखाने के लिए 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}] &

घुंघराले कोष्ठक का उपयोग करके एक स्ट्रिंग के रूप में इनपुट लें {और }। आउटपुट एक बहु-पंक्ति स्ट्रिंग।