समान ब्रैकेट प्रकार

Question

इस प्रश्न पर आधारित

एक स्ट्रिंग को देखते हुए, प्रत्येक ब्रैकेट ()[]{}<>को उपयुक्त प्रकार के ब्रैकेट से बदलें, ताकि कोष्ठक मेल खाता हो, और नेस्टेड ब्रैकेट चक्र निम्नानुसार हो:

1. बाह्यतम हैं ()
2. सीधे अंदर ()होना चाहिए[]
3. सीधे अंदर []होना चाहिए{}
4. सीधे अंदर {}होना चाहिए<>
5. सीधे अंदर फिर से <>होगा ()(चक्र)

सभी गैर-ब्रैकेट चार्ट ठीक वैसे ही रहने चाहिए जैसे वे हैं। खुले कोष्ठक केवल कुछ प्रकार के खुले कोष्ठक के साथ बदले जा सकते हैं, और निकट कोष्ठक के साथ कोष्ठक।

इनपुट हमेशा यह संभव बना देगा। इसका मतलब है कि अगर उनके प्रकार को नजरअंदाज कर दिया गया है तो इसके कोष्ठक सही ढंग से मेल खाते हैं। तो, {ab<)c]एक वैध इनपुट है, लेकिन है ab)(cdया ab((cdनहीं।

उदाहरण:

2#jd {¤>. = 2#jd (¤).
abcdef    = abcdef
(3×5+(4-1)) = (3×5+[4-1])
<<<>><<>><<<<<<>>>>>>> = ([{}][{}][{<([{}])>}])

इस तरह से इनपुट के मूल रूपांतरण का उपयोग (भाषा के ऑटो सिंटैक्स) की अनुमति नहीं है।

हमेशा की तरह: सबसे छोटा कोड जीतता है।

Comments

मैं चुनौती नहीं समझता। इनपुट के संदर्भ में आउटपुट क्या होना चाहिए?

— xnor

@xnor आउटपुट चार प्रकार के ब्रैकेट्स को छोड़कर इनपुट की तरह ही स्ट्रिंग होना चाहिए। पैटर्न से मेल करने के लिए उन्हें प्रतिस्थापित करने की आवश्यकता है।

— डिर्क रीचेल

आह, अब मैं देख रहा हूं। मुझे समझ नहीं आया कि "होना चाहिए" वे चीजें हैं जिन्हें आप सच करने वाले हैं। मैं इसे स्पष्ट करने के लिए प्रयास करूँगा।

— xnor

@DirkReichel मुझे नहीं लगता कि ऐसी कोई चीज़ है जिसके बारे में आपको चिंता करने की ज़रूरत है। मैं कल्पना नहीं कर सकता कि कोई भी भाषा इस विशिष्ट परिवर्तन को मूल रूप से कर सकती है, और अप्रत्याशित घटना में ऐसी कोई भाषा है जिसका अर्थ है कि उस भाषा में उत्तर बहुत दिलचस्प नहीं होंगे।

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

@DirkReichel क्या बात है? बस ASCII के साथ रहें। विभिन्न पात्रों का उपयोग करने से असीसी-केवल भाषाओं पर अनावश्यक प्रतिबंधों के अलावा कुछ भी चुनौती नहीं है।

— पलटें

Answer 1

जावास्क्रिप्ट (ईएस 6), 79 बाइट्स

s=>s.replace(/./g,c=>~(p=l.indexOf(c))?l[p&4?--k&3|4:k++&3]:c,l='([{<)]}>',k=0)

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

let f =

s=>s.replace(/./g,c=>~(p=l.indexOf(c))?l[p&4?--k&3|4:k++&3]:c,l='([{<)]}>',k=0)

console.log(f("2#jd {¤>."));
console.log(f("abcdef"));
console.log(f("(3×5+(4-1))"));
console.log(f("<<<>><<>><<<<<<>>>>>>>"));

Answer 2

लेक्स, 132 बाइट्स

%{
int i,o[4]={40,91,123,60};
%}
%%
[[({<] {putchar(o[i++&3]);}
[])}>] {putchar(o[--i&3]+2-!(i&3));}
%%
yywrap(){}
main(){yylex();}

Comments

आप flexकुछ संख्या में बाइट्स (शायद 2, 3 या 4) की कीमत पर क्रमशः 27 बाइट्स (पोर्टेबल लेक्स) या 30 बाइट्स ( संकलक के रूप में उपयोग करके ) को क्रमशः दो या तीन लाइनों को हटा सकते हैं। -llपरिणामी सी फ़ाइल को लिंक करते समय कमांड लाइन विकल्प के लिए दंड में । (यह है, lex brackets.l; cc lex.yy.cआप के साथ संकलन करने के बजाय , आप के साथ संकलन करते हैं lex brackets.l; cc lex.yy.c -ll।) यह निश्चित रूप से इस स्थिति में बनाने के लायक है।

Answer 3

जावा, 155 बाइट्स

a->{String s="([{<)]}>";for(int i=0,j=0,k;i<a.length;i++){k=s.indexOf(a[i]);if(k>3){a[i]=s.charAt(--j%4+4);}else if(k>-1){a[i]=s.charAt(j++%4);}}return a;}

लैम्ब्डा कि char[]यह एक तर्क के रूप में लेता है । हम सरणी के माध्यम से लूप करते हैं, यह sएक चर ( k) में हमारी स्ट्रिंग की कोष्ठक ( ) में स्थिति को संग्रहीत करता है । हम जाँचते हैं कि यह एक उद्घाटन या समापन ब्रैकेट है ( s.indexAt()), और इसे उपयुक्त नेकेट के आधार पर प्रतिस्थापित करें यह नेस्टिंग ( s.charAt()) के स्तर पर है , उचित रूप से लूपिंग%4

Answer 4

हास्केल, 126 बाइट्स

b="([{<"
d=")]}>"
y=cycle
(!)=elem
f(e:c)n(x:r)|x!b=y b!!n:f(y d!!n:e:c)(n+1)r|x!d=e:f c(n-1)r|1<3=x:f(e:c)n r
f c n s=s
f" "0

इसे आइडोन पर आज़माएं। उपयोग:

*Main> f" "0 "<<<>><<>><<<<<<>>>>>>>"
"([{}][{}][{<([{}])>}])"

व्याख्या

fतीन तर्क लेता है: एक स्ट्रिंग जो कोष्ठक को बंद करने के लिए स्टैक का काम करती है, एक nनेस्टिंग-डेप्थ और इनपुट स्ट्रिंग को गिनने के लिए।

f c n "" = ""                            -- base case for recursion: input string is empty
f (e:c) n (x:r)                          -- for the current char x
   | elem x "([{<" =                     -- check if it is an opening bracket
       (cycle "([{<")!!n :               --   if so, replace it with a bracket of the current nesting depth
           f ((cycle ")]}>")!!n : e : c) --   push the matching closing bracket on the stack
               (n+1) r                   --   increase depth level and check the next char
   | elem x ")]}>" =                     -- if x is a closing bracket
       e :                               --   replace it by the closing bracket from on top of the stack
           f c (n-1) r                   --   decrement depth level and check the next char
   | otherwise     = x : f (e:c) n r     -- otherwise keep x and check the next char