ब्रैक्स में भरें

Question

सामान्य कोष्ठक ( (), [], <>और {}), अच्छा और स्पष्ट कर रहे हैं लेकिन किसी को लगा कि यह कोष्ठक के रूप में गैर ब्रैकेट वर्णों का उपयोग करने के लिए एक अच्छा विचार होगा। ये पात्र, |और ", अस्पष्ट हैं। उदाहरण के लिए करता है

""""

के अनुरूप

(())

या

()()

यह बताना असंभव है।

उदाहरण के लिए, जब आप अस्पष्ट ब्रैकेट के प्रकारों को मिलाते हैं तो चीजें दिलचस्प होने लगती हैं

"|""||""|"

निम्नलिखित में से कोई भी हो सकता है

([(([]))]),([()[]()]),([()][()])

कार्य

आपका काम अस्पष्ट पात्रों से बना एक स्ट्रिंग लेना है और लेखक द्वारा किए जा सकने वाले सभी संभावित संतुलित तारों को आउटपुट करना है।

अधिक वस्तुतः आप आउटपुट सभी संतुलित तार कि जगह बनाया जा सकता है |के साथ या तो [या ]और "के साथ या तो (या )। आपको किसी भी संतुलित स्ट्रिंग को दो बार आउटपुट नहीं करना चाहिए।

आईओ

इनपुट के रूप में आप से मिलकर एक स्ट्रिंग ले जाना चाहिए |और "। यदि आप इसके अलावा दो अलग-अलग वर्णों का चयन करना चाहते हैं |और "आप ऐसा करने वाले प्रतिस्थापन के रूप में सेवा कर सकते हैं। आपको संतुलित तारों के एक कंटेनर का उत्पादन करना चाहिए। आप किसी अन्य दो ब्रैकेट जोड़े के साथ आउटपुट में []और बदलने का विकल्प चुन सकते हैं ()(() , [], <>या {}) आप चाहते हैं। आपका आउटपुट प्रारूप पूरे रन के अनुरूप होना चाहिए।

स्कोरिंग

ये है कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

परीक्षण के मामलों

"" -> ["()"]
"|"| -> []
||| -> []
"""" -> ["(())","()()"]
""|| -> ["()[]"]
"|"||"|" -> ["([([])])"]    
"|""||""|" -> ["([(([]))])","([()[]()])","([()][()])"]    

Comments

एक BrainFlak उत्तर की प्रतीक्षा करता है

— caird coinheringaahing

क्या हम स्ट्रिंग्स के बजाय पूर्णांक का उपयोग कर सकते हैं? अंकों या पूर्णांकों की सूची के बारे में क्या?

— जर्बद

@ ज़र्ब ज़रूर ठीक है

— पोस्ट रॉक गार्फ हंटर

Answer 1

पायथन 2 , 135 बाइट्स

s=input()
for k in range(2**len(s)):
 try:c=''.join("[]() , ,"[int(c)|k>>i&1::4]for i,c in enumerate(s));eval(c);print c[::2]
 except:0

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

जैसे इनपुट की उम्मीद है 2002 बजाय है"||" , और उद्धरण में लिपटे।

स्ट्रिंग के लिए "ओपन" और "क्लोज़" के सभी 2 ^एन संभव असाइनमेंट पर Iterates , cजैसे तार बनाते हैं:

"( [ ( ),],[ ( ),],),( ),"

अगर eval यह स्ट्रिंग एक अपवाद फेंकता है, तो यह बेजोड़ है। यदि नहीं, तो हम प्रिंट करते हैं c[::2]:

([()][()])()

Answer 2

रेटिना , ५ ९ ५६ 55 बाइट्स

0`"
<$%">
}0`'
{$%"}
.+
$&_$&
+m`^_|(<>|{})(?=.*_)

A`_

इसे ऑनलाइन आज़माएं! दुर्भाग्य से मिलान किए गए कोष्ठक के दो सेट के लिए परीक्षण एक एकल .NET रेगेक्स की गंभीरता से अधिक है, इसलिए यह मैन्युअल रूप से जांच करने के लिए 15 बाइट बचाता है। संपादित करें: सहेजा गया 3 बाइट्स @ H.PWiz के लिए धन्यवाद। स्पष्टीकरण:

0`"
<$%">

एक खोजें "और लाइन की दो प्रतियां बनाएं, एक के साथ एक <और एक के साथ >। इसे एक "बार में करें, ताकि प्रत्येक" लाइनों की संख्या दोगुनी हो ।

}0`'
{$%"}

इसी तरह से ', {और }। फिर, सभी "s और जब तक प्रतिस्थापित करते रहें' कि सभी प्रतियों पर सभी s प्रतिस्थापित नहीं हो जाते।

.+
$&_$&

कोष्ठकों का एक डुप्लिकेट बनाएं, a द्वारा अलग किया गया _ ।

+m`^_|(<>|{})(?=.*_)

डुप्लिकेट में, मिलान किए गए ब्रैकेट को बार-बार हटाएं, जब तक कि कोई भी बचा न हो, जिस स्थिति में भी हटा दें _।

A`_

सभी पंक्तियों को हटा दें जो अभी भी हैं _।

रेटिना , 74 71 70 बाइट्स

0`"
<$%">
}0`'
{$%"}
Lm`^(.(?<=(?=\3)(<.*>|{.*}))(?<-3>)|(.))+(?(3)_)$

इसे ऑनलाइन आज़माएं!स्पष्टीकरण: पहले दो चरण ऊपर हैं। तीसरा चरण सीधे मिलान वाले ब्रैकेट के दो सेटों के मिलान के परिणाम को प्रिंट करता है। यह .NET के बैलेंसिंग समूहों का उपयोग करता है। मैच के प्रत्येक चरण में, रेगेक्स एक चरित्र से मेल खाने की कोशिश करता है, फिर मिलान वाले ब्रैकेट की एक जोड़ी के लिए वापस देखें, फिर जांचें कि स्टैक के शीर्ष खुले ब्रैकेट से मेल खाते हैं। यदि यह ऐसा कर सकता है, तो इसका मतलब है कि ब्रैकेट संतुलित है, और खुले ब्रैकेट को स्टैक से पॉपअप किया गया है। अन्यथा, धारणा यह है कि हम एक खुले ब्रैकेट में हैं जिसे स्टैक पर धकेलने की आवश्यकता है। अगर ये धारणाएं नहीं चलती हैं, तो अंत में स्टैक खाली नहीं होगा और मैच विफल हो जाएगा।

वैकल्पिक दृष्टिकोण, भी 74 71 बाइट्स:

Lm`^((?=(<.*>|{.*})(?<=(.))).|\3(?<-3>))+(?(3)_)$

यहां, हम या तो <... >या {... के लिए आगे देखते हैं }, फिर स्टैक पर बंद ब्रैकेट को पुश करने के लिए पीछे देखते हैं । अन्यथा, हमें उस समापन ब्रैकेट को मिलान और पॉप करना होगा जिसे हमने पहले कैप्चर किया था। इस संस्करण में रेगेक्स शायद इसे स्ट्रिंग के अंत में भी नहीं बना सकता है, लेकिन <<<>अगर हम खाली स्टैक की जांच नहीं करते हैं तो कुछ तार जैसे जाल से फिसल जाएंगे।

Comments

आप विभिन्न पात्रों का उपयोग करके बचने पर कुछ बाइट्स बचा सकते हैं

— H.PWiz

@ H.PWiz आह, मैंने वैकल्पिक ब्रैकेट जोड़े के उपयोग के बारे में उस बिट को अनदेखा कर दिया होगा, धन्यवाद!

— नील

आप |इनपुट में भी बदल सकते हैं

— H.PWiz

Answer 3

हस्क , 19 बाइट्स

fo¬ω`ḞoΣx½¨÷₂¨ΠmSe→

इसे ऑनलाइन आज़माएं! dsइनपुट में वर्ण और संबंधित ब्रैकेट जोड़े deऔर stआउटपुट में उपयोग करता है।

व्याख्या

यह विचार इनपुट के सभी संभावित कोष्ठक को उत्पन्न करना है और जब हम बार-बार निकटवर्ती कोष्ठक को हटाते हैं तो खाली स्ट्रिंग को कम करते हैं। ¨÷₂¨एक संकुचित स्ट्रिंग है कि में फैलता है "dest", जो है, क्योंकि यह एक छोटी संकुचित रूप है और आसन्न कोड पॉइंट्स के साथ चरित्र जोड़े के होते चुना गया था। इस प्रकार कार्यक्रम निम्नलिखित के बराबर है।

fo¬ω`ḞoΣx½"dest"ΠmSe→  Implicit input, say "ddssdd".
                 m     Map over the string:
                  Se    pair character with
                    →   its successor.
                       Result: ["de","de","st","st","de","de"]
                Π      Cartesian product: ["ddssdd","ddssde",..,"eettee"]
f                      Keep those strings that satisfy this:
                        Consider argument x = "ddsted".
   ω                    Iterate on x until fixed:
         ½"dest"         Split "dest" into two: ["de","st"]
    `Ḟ                   Thread through this list (call the element y):
        x                 Split x on occurrences of y,
      oΣ                  then concatenate.
                          This is done for both "de" and "st" in order.
                        Result is "dd".
 o¬                    Is it empty? No, so "ddsted" is not kept.
                      Result is ["destde","ddstee"], print implicitly on separate lines.

Answer 4

पर्ल, 56 55 53 बाइट्स

के लिए शामिल +1हैn

के [लिए []और के {लिए उपयोग करता है{}

perl -nE 's%.%"#1$&,+\\$&}"^Xm.v6%eg;eval&&y/+//d+say for< $_>' <<< "[{[[{{[[{["

सभी 2 ^ एन संभावनाएं उत्पन्न करता है, फिर evalयह जांचने के लिए पर्ल का उपयोग करता है कि क्या '+ [+ {}] जैसे स्ट्रिंग मान्य कोड है और यदि +परिणाम निकालता है और प्रिंट करता है

Answer 5

एपीएल (डायलॉग क्लासिक) , 55 53 बाइट्स

{a/⍨~×≢¨'\(\)|\[]'⎕r''⍣≡a←⊃∘'()[]'¨¨(⊂'".'⍳⍵)+,⍳2⊣¨⍵}

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

Answer 6

स्वच्छ , 203 186 179 बाइट्स

?['(':l][')':t]= ?l t
?['[':l][']':t]= ?l t
?l[h:t]= ?[h:l]t
?[][]=True
?_ _=False
@['"']=[['('],[')']]
@['|']=[['['],[']']]
@[h:t]=[[p:s]\\[p]<- @[h],s<- @t]
$s=[k\\k<- @s| ?[]k]

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

केवल पैटर्न-मिलान और समझ का उपयोग करता है।

Answer 7

पर्ल, 56 बाइट्स

के लिए शामिल +हैn

[आउटपुट के लिए इनपुट का उपयोग करता है [या]

{आउटपुट के लिए इनपुट का उपयोग करता है {या}

perl -nE '/^((.)(?{$^R.$2})(?1)*\2(?{$^R.=$2^v6}))*$(?{say$^R})^/' <<< "[{[[{{[[{["

बैकट्रैकिंग के दौरान किए गए विकल्पों पर नज़र रखते हुए ब्रेसिज़ से मेल करने के लिए एक पर्ल विस्तारित रेगेक्स का उपयोग करता है। यह सभी 2 ^ एन उम्मीदवारों को उत्पन्न करने की तुलना में बहुत अधिक कुशल हो सकता है क्योंकि यह पहले से ही इनपुट स्ट्रिंग के माध्यम से भाग के दौरान कई असंभव असाइनमेंट को अस्वीकार करता है।

Answer 8

कोटलिन , 240 236 234 बाइट्स

fold(listOf("")){r,c->r.flatMap{i->when(c){'"'->"()".map{i+it}
else->"[]".map{i+it}}}}.filter{val d=ArrayList<Char>()
it.all{fun f(c:Any)=d.size>1&&d.removeAt(0)==c
when(it){')'->f('(')
']'->f('[')
else->{d.add(0,it);1>0}}}&&d.size<1}

सजा हुआ

    fold(listOf("")) {r,c ->
        r.flatMap {i-> when(c) {
            '"'-> "()".map {i+it}
            else -> "[]".map {i+it}
        }}
    }.filter {
        val d = ArrayList<Char>()
        it.all {
            fun f(c:Any)=d.size>1&&d.removeAt(0)==c
            when(it) {
                ')' -> f('(')
                ']' -> f('[')
                else -> {d.add(0,it);1>0}
            }
        } && d.size<1
    }

परीक्षा

private fun String.f(): List<String> =
fold(listOf("")){r,c->r.flatMap{i->when(c){'"'->"()".map{i+it}
else->"[]".map{i+it}}}}.filter{val d=ArrayList<Char>()
it.all{fun f(c:Any)=d.size>1&&d.removeAt(0)==c
when(it){')'->f('(')
']'->f('[')
else->{d.add(0,it);1>0}}}&&d.size<1}

data class Test(val input: String, val outputs: List<String>)

val tests = listOf(
    Test("""""""", listOf("()")),
    Test(""""|"|""", listOf()),
    Test("""|||""", listOf()),
    Test("""""""""", listOf("(())","()()")),
    Test("""""||""", listOf("()[]")),
    Test(""""|"||"|"""", listOf("([([])])")),
    Test(""""|""||""|"""", listOf("([(([]))])","([()[]()])","([()][()])"))
)

fun main(args: Array<String>) {
    for ((input, output) in tests) {
        val actual = input.f().sorted()
        val expected = output.sorted()
        if (actual != expected) {
            throw AssertionError("Wrong answer: $input -> $actual | $expected")
        }
    }

संपादित करता

• -4 जर्पैपसेल - प्रचलित जाँच की भविष्यवाणी करें
• -2 जर्पापसेल - true-> 1>0और == 0->< 1

Answer 9

सी (जीसीसी) , 315 बाइट्स

• छत के लिए धन्यवाद 19 बाइट्स।

j,b;B(char*S){char*s=calloc(strlen(S)+2,b=1)+1;for(j=0;S[j];b*=(S[j]<62||*--s==60)*(S[j++]-41||*--s==40))S[j]==60?*s++=60:0,S[j]<41?*s++=40:0;return*s>0&*--s<1&b;}f(S,n,k)char*S;{if(n<strlen(S))for(k=2;k--;)S[n]==46-k-k?S[n]=40+k*20,f(S,n+1),S[n]=41+k*21,f(S,-~n),S[n]=46-k-k:0;else B(S)&&puts(S);}F(int*S){f(S,0);}

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

---

सी (जीसीसी) , 334 बाइट्स (पुराना संस्करण)

j,b;B(char*S){char*s=calloc(strlen(S)+2,1)+1;for(b=1,j=0;S[j];j++){if(S[j]==60)*s++=60;if(S[j]<41)*s++=40;b*=!(S[j]>61&&*--s!=60)*!(S[j]==41&&*--s!=40);}return*s>0&*--s<1&b;}f(S,n,k)char*S;{if(n>=strlen(S))return B(S)&&puts(S);for(k=0;k<2;k++)S[n]==46-k-k&&(S[n]=40+k*20,f(S,n+1),S[n]=41+k*21,f(S,-~n),S[n]=46-k-k);}F(char*S){f(S,0);}

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

---

स्पष्टीकरण (पुराना संस्करण)

j,b;B(char*S){                   // determine if string is balanced
 char*s=calloc(strlen(S)+2,1)+1; // array to store matching brackets
 for(b=1,j=0;S[j];j++){          // loop through string (character array)
  if(S[j]==60)*s++=60;           // 60 == '<', opening bracket
  if(S[j]<41)*s++=40;            // 40 == '(', opening bracket
  b*=!(S[j]>61&&*--s!=60)*       // 62 == '>', closing bracket
   !(S[j]==41&&*--s!=40);}       // 41 == ')', closing bracket
 return*s>0&*--s<1&b;}           // no unmatched brackets and no brackets left to match
f(S,n,k)char*S;{                 // helper function, recursively guesses brackets
 if(n>=strlen(S))                // string replaced by possible bracket layout
  return B(S)&&puts(S);          // print if balanced, return in all cases
 for(k=0;k<2;k++)                // 46 == '.', guess 40 == '(',
  S[n]==46-k-k&&(S[n]=40+k*20,   //  guess 41 == '(', restore
   f(S,n+1),S[n]=41+k*21,        // 44 == ',', guess 60 == '<',
   f(S,-~n),S[n]=46-k-k);}       //  guess 62 == '>', restore
F(char*S){f(S,0);}               // main function, call helper function

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

Comments

क्या आप कॉलोक से छुटकारा पाने के लिए GCC वैरिएबल लंबाई सरणियों का उपयोग नहीं कर सकते हैं?

— टन हास्पेल

@TonHharma मैं फिर भी, या तो सरणी को एक पॉइंटर में बदलने या किसी अन्य इंडेक्स वेरिएबल को पेश करने की आवश्यकता है, जो मुझे नहीं पता है कि क्या यह इसके लायक है, क्योंकि मैं उपयोग कर रहा हूं *s++ कुछ स्थानों पर ।

— जोनाथन फ्रीच

char S[n],*s=Sअभी भी इससे कम हैchars*s=calloc(n,1)

— टन इंजील

@ टोनहोस मैं वास्तव में नहीं जानता कि क्यों, हालांकि काम नहीं करता है ।

— जोनाथन फ्रीच

@ceilingcat धन्यवाद।

— जोनाथन फ्रेच