ब्रैकेट संतुलन

Question

आपको एक (संभवतः खाली) स्ट्रिंग युक्त ब्रैकेट ( [{()}]) और किसी भी अन्य वर्ण ( A- Z, a- z, 0- 9, विराम चिह्न) दिए जाएंगे । आपको यह जाँचने की आवश्यकता है कि क्या यह निम्नलिखित नियमों का पालन करता है:

• गैर-ब्रैकेट वर्णों को अनदेखा किया जाता है।
• हर खुले ब्रैकेट [{(में क्लोजिंग ब्रैकेट होता है )}]। इसलिए [](अनुमति नहीं है।
• ब्रैकेट को ठीक से नेस्टेड किया जाता है। [(])अनुमति नहीं है।
• घुंघराले ब्रैकेट में वर्गाकार कोष्ठक नहीं हो सकते। साधारण कोष्ठक में घुंघराले या वर्गाकार कोष्ठक नहीं हो सकते। तो [({})], [{[]}]और ({})अनुमति नहीं है। ब्रैकेट को समान ब्रैकेट के साथ नेस्टेड किया जा सकता है, इसलिए [[{((()))}{{(())}}]()]{()}अनुमति दी गई है।

आउटपुट आपकी पसंद के अनुसार एक एकल सत्य / गलत मूल्य है।

सबसे छोटा कोड जीतता है।

---

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

b[[a{(/)}(())+={{}-}],] -> मान्य

([h][e][l][l][o]) -> अमान्य है

[///[{(\/(arg()))}1{{((-)-2)}}]()]{()} -> मान्य

hi -> मान्य

Comments

फिक्स असंतुलित कोष्ठक

— FUZxxl 11

@FUZxxl यह एक बहुत कठिन चुनौती की तरह लग रहा है। मुझे ऐसा लगता है कि कहीं और एक और डुबकी है।

— मार्टिन एंडर

@ मार्टिनबटनर हाँ, यह कर सकते हैं। मैंने कुछ टेस्टकेस जोड़े हैं। और क्या आपको वह डुप्लिकेट मिला जिसकी आप तलाश कर रहे थे?

— ghosts_in_the_code 16

@ मार्टिनबटनर: यह चुनौती हो सकती है कि आप क्या सोच रहे थे।

— इल्मरी करोनें 22

मुझे लगता है कि हमें इसके डुप्लिकेट के रूप में अन्य प्रश्न को बंद करना चाहिए; यह बेहतर है क्योंकि इसमें कम बोनस है।

— lirtosiast

Answer 1

रेटिना , 84 बाइट्स

^([^][}{)(]|()\(|(?<-2>)\)|(?!\2)((){|(?<-4>)}|(?!\4)(()\[|(?<-6>)])))*$(?!\2|\4|\6)

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

यह मूल कोष्ठक-जाँच .NET regex का एक काफी सीधा (लेकिन गोल्फ वाला) विस्तार है ।

जबकि संतुलन समूहों के साथ यह बहुत संभव है, पर्ल की पुनरावृत्ति निश्चित रूप से यहां बढ़त है । हालांकि, या तो दृष्टिकोण को इनपुट को कम करने के पक्ष में एकल रेगेक्स मैच की लालित्य को खाई द्वारा धीरे-धीरे पीटा जाता है, दोहराया प्रतिस्थापन के माध्यम से, जाता है कि जैसा कि डिजिटल ट्रॉमा का sed उत्तर करता है । यह रेटिना में 34 बाइट्स में लागू किया जा सकता है, लेकिन मैं खुद को कोड पोस्ट करने में संकोच कर रहा हूं, क्योंकि मैं इस विचार के साथ नहीं आया था।

Answer 2

रेटिना, ३४

सबसे पहले, क्रेडिट जहां क्रेडिट देय है:

• @ @ N posteduɐɯɹɐ ן oɯ जिन्होंने पहली बार इस दृष्टिकोण को पोस्ट किया था ।
• @ मार्टिनबटनर जिन्होंने इस सटीक उत्तर का सुझाव दिया था, लेकिन एक स्पोर्ट्समैन द्वारा खुद को पोस्ट न करने के लिए बहुत अच्छा था।

मैं स्वतंत्र रूप से (बाद में) sed में एक ही दृष्टिकोण के साथ आया था , इसलिए मुझे उम्मीद है कि मैं इसे पोस्ट करने के लिए किसी भी पैर की उंगलियों ( बड़े या अन्यथा) पर नहीं फैल रहा हूं :

[^][(){}]

+`\(\)

+`{}

+`\[]

^$

तो अब एक के साथ sudo apt-get install mono-completeऔर git clone https://github.com/mbuettner/retina.gitमेरे पास मेरे उबंटू वीएम पर एक काम करने वाला रेटिना है। यहाँ परीक्षण उत्पादन है:

$ while read; do echo "Input: \"$REPLY\", Ouput: $( mono Retina.exe -s brbal.ret <<< "$REPLY" )" ; done < ../brbal.txt 
Input: "[[{((()))}{{(())}}]()]{()}", Ouput: 1
Input: "b[[a{(/)}(())+={{}-}],]", Ouput: 1
Input: "[///[{(/(arg()))}1{{((-)-2)}}]()]{()}", Ouput: 1
Input: "hi", Ouput: 1
Input: "", Ouput: 1
Input: "", Ouput: 1
Input: "([h][e][l][l][o])", Ouput: 0
Input: "[](", Ouput: 0
Input: "[(])", Ouput: 0
Input: "[({})]", Ouput: 0
Input: "[{[]}]", Ouput: 0
Input: "({})", Ouput: 0
$ 

Comments

@ThomasKwa परीक्षण आउटपुट देखें। मेरा मानना ​​है कि कोड सही है और सभी टेस्टकेस गुजर रहे हैं। क्या कोई विशेष समस्या है जिसे आप कोड में देखते हैं, या विशेष रूप से आपको लगता है कि असफल हो जाएगा?

— डिजिटल आघात

@ThomasKwa मैंने उनका कोड पोर्ट नहीं किया, क्योंकि मुझे कोई सुराग नहीं है कि ESMIN का कोई टुकड़ा क्या करता है। मैंने इस कोड को सिर्फ इस आधार पर लिखा था कि यह ऐसा दिखता है कि यह ऐसा करेगा, इसलिए मुझे नहीं लगता कि इसका कोई कारण है कि इसमें समान बग होना चाहिए।

— मार्टिन एंडर

वाह, @ मार्टिनबटनर, आपको यह सही लगा! हाँ, मैंने सोचा था कि मिलान वाले कोष्ठकों को अंदर-बाहर करने की जगह पुनरावृत्ति सबसे तार्किक थी। कोड स्पेक्स को फिट करने के लिए एक त्वरित ट्विक ने इसे काम किया।

— मामा फन रोल

Answer 3

सेड, ५३

s/[^][(){}]//g
:;s/()//;t
:b;s/{}//;tb
:c;s/\[\]//;tc

यहां मैं यह दावा कर रहा हूं कि चूंकि sedवास्तव में सत्य / मिथ्या की अवधारणा नहीं है, तो मैं सत्य का अर्थ करने के लिए खाली स्ट्रिंग को परिभाषित कर रहा हूं और अन्य सभी तार का अर्थ है कि गलत होना।

यदि यह स्वीकार्य नहीं है, तो हम कुछ पंक्तियों को जोड़ सकते हैं, इस प्रकार:

सेड, ६६

s/[^][(){}]//g
:;s/()//;t
:b;s/{}//;tb
:c;s/\[\]//;tc
/./c0
/^$/c1

यह झूठे के लिए 0 और सच के लिए 1 आउटपुट देता है।

Comments

सटीक उसी समाधान के रेटिना संस्करण (34 बाइट्स पर; मुद्रण 0या 1) के लिए मोलमारनफुल के उत्तर पर मेरी टिप्पणी देखें । मैं यह नहीं कह सकता कि किसे पोस्ट करना चाहिए, लेकिन यह शायद आप दोनों में से एक होना चाहिए।

— मार्टिन एंडर

Answer 4

सीजेएम, 27 26 बाइट्स

"(){}[]"q1$f&_,@2/e*{/s}/!

यह प्रिंट 1 (सत्य) या 0 (मिथ्या)। इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें।

यह काम किस प्रकार करता है

"(){}[]"                    Push that string.
        q                   Read all input and push it on the stack.
         1$                 Copy the bracket string.
           f&               Intersect each input character with the bracket string.
                            This pushes an array of singleton and empty strings.
             _,             Get the length of the array (L), i.e., the number of
                            characters in the original input.
               @            Rotate the bracket string on top of the stack.
                2/          Split it into ["()" "{}" "[]"].
                  e*        Repeat each character pair L times.
                    {  }/   For each character pair.
                     /      Split the string on the stack at occurrences of that
                            character pair. This dosn't work properly the first
                            time, since there's a string array on the stack.
                      s     Flatten the resulting array of strings.
                         !  Apply logical NOT.

Answer 5

S, 43 चार्ट / 62 बाइट्स

!Մ(Մ(Մ(ïċ/⁅⬮[\]{}]⌿),`⬮`,⬯),`{}`,⬯),`[]`,⬯)

Try it here (Firefox only).

नहीं।

---

हालाँकि, यदि मैं नई कार्यान्वित सुविधाओं का उपयोग करता हूं, तो मैं 28 चार्ट / 47 बाइट्स प्राप्त कर सकता हूं:

!ïċ/⁅⬮[\]{}]⌿)ė`⬮”ė`{}”ė`[]”

Comments

ओह्ह, क्या आप मेल खाते हुए कोष्ठकों को अंदर से बाहर निकाल रहे हैं? रेटिना में यह मात्र 34 बाइट्स होगा: pastebin.com/bU77LzbR

— मार्टिन एंडर

Answer 6

जाप , 42 37 बाइट्स

एक सुविधा के साथ 5 बाइट्स सहेजे गए, मुझे एहसास नहीं हुआ कि मेरी अपनी भाषा थी ... इसे जोड़ने के लिए धन्यवाद, @Downgoat!

Japt वास्तव में बेहतर RegExp समर्थन की जरूरत है ...

!Uo"()[\\]\{}" e"\\(\\)" e"\{}" e"\\[]

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

यह काम किस प्रकार करता है

               // Implicit: U = input string
Uo"()[\\]\{}"  // Remove all non-bracket.
e"\\(\\)"      // Recursively remove all pairs of simple brackets.
e"\{}"         // Recursively remove all pairs of curly brackets.
e"\\[]         // Recursively remove all pairs of square brackets.
!              // Return the Boolean NOT of the result.
               // (true for empty string, false for anything else)
               // Implicit: output last expression

Answer 7

C99, 226 208 207 बाइट्स

यह मेरा पहला मौका है जब मैंने किसी चीज को हासिल करने की कोशिश की है

#define S s[i]
t(s,i)char*s;{int a[]={['[']=0,['{']=0,['(']=0};for(i=0;S*!(S=='{'&a['(']|S=='['&(a['(']|a['{'])|S==']'&(a['(']|a['{'])|S=='}'&a['(']);i++)a[S]++,a[S-S/90-1]--;return !(a['[']+a['{']+a['(']);}

पठनीय:

int t(char* s){
    int a[265]={['[']=0,['{']=0,['(']=0};
    for(int i=0;s[i]&&!((s[i]=='{'&a['(']>0)|(s[i]=='['&(a['(']>0|a['{']>0))|(s[i]==']'&(a['(']>0|a['{']>0))|(s[i]=='}'&a['(']>0));i++){
        a[s[i]]++;
        a[s[i]-(s[i]/90+1)]--;
    }
    return !(a['[']+a['{']+a['(']);
}

एक बफर अतिप्रवाह है, लेकिन यह कुछ भी प्रभावित नहीं करता है - मेरा मानना ​​है कि यह संरेखण के कारण है।

Comments

आप अंतरिक्ष में छोड़ सकते हैंchar* s

— Cyoce

पता नहीं था कि - धन्यवाद

— dj0wns

Answer 8

पर्ल, 50 + 1 = 51 बाइट्स

$_=/^((([^][)(}{]|\((?3)*\))|{(?2)*})|\[(?1)*])*$/

सत्य के लिए -pध्वज और प्रिंट की आवश्यकता है और 1मिथ्या परिणामों के लिए कुछ भी नहीं है। मैं -pएक के रूप में गिन रहा हूं , क्योंकि इसे इसके साथ जोड़ा जा सकता है -e:

> perl -pe '$_=/^((([^][)(}{]|\((?3)*\))|{(?2)*})|\[(?1)*])*$/'

कोड मूल रूप से इनपुट के खिलाफ एक सादा रेगेक्स मैच है, जो पर्ल के निफ्टी रिकर्सिव रेगेक्स फीचर का उपयोग करता है।

मेरी मदद करने के लिए डेनिस के लिए धन्यवाद यह परीक्षण और पर्ल बायलरप्लेट को गोल्फ।

Answer 9

पायथन 3: 120 बाइट्स

@ अदनान के उत्तर पर निर्माण , फिर से उपयोग करने के लिए छोटा साबित हुआ:

import re
x=re.sub('[^[\](){}]','',input())  
for i in('()','{}','[]'):  
 while x.find(i)>=0:x=x.replace(i,'')  
print(x=='')

Answer 10

पायथन 3, 196 170 160 154 बाइट्स

6 बाइट बचाने के लिए मेगो को धन्यवाद, लंबे समय तक:

d=y=""
for C in input():
 for a in "[](){}":y+=C*(C==a)
 y=y.replace("()",d)
x=y
for r in y:x=x.replace("{}",d)
for s in y:x=x.replace("[]",d)
print(x==d)