लंबाई n के सभी ब्रेस-स्ट्रिंग्स उत्पन्न करें

Question

एक ब्रेस स्ट्रिंग को एक स्ट्रिंग के रूप में परिभाषित किया गया है जिसमें अक्षर *()[]सही ढंग से मेल खाते हैं:

[brace-string] ::= [unit] || [unit] [brace-string]
[unit]         ::= "" || "*" || "(" [brace-string] ")" || "[" [brace-string] "]"

यह एक मान्य ब्रेस-स्ट्रिंग है:

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

लेकिन ये नहीं हैं:

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

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

विशेष विवरण

• आप किसी भी क्रम में स्ट्रिंग्स का उत्पादन कर सकते हैं।
• आप एक सूची या एक अलग चरित्र द्वारा अलग किए गए स्ट्रिंग के रूप में आउटपुट कर सकते हैं।
• आपके प्रोग्राम को 0 सही ढंग से संभालना चाहिए। लंबाई 0 का 1 संभावित ब्रेस-स्ट्रिंग है, जो खाली स्ट्रिंग है ""।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

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

0. 
1. *
2. ** () []
3. *** ()* []* (*) [*] *() *[]
4. **** ()** []** (*)* [*]* (**) **() **[] *(*) *[*] (()) ()() ()[] ([]) [**] [()] [[]] []() [][] *()* *[]*

Comments

आउटपुट में प्रविष्टियों की संख्या A025235 है

— गेब्रियल बेनामी

@GabrielBenamy आह। मैं सोच रहा था कि क्या पहले देखा गया था। दिलचस्प।

— बजे फल

जीतने की स्थिति क्या है? मैं सबसे छोटा कार्यक्रम (कोड गोल्फ) मानता हूं।

— जर्ब

सम्बंधित।

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

चूंकि हर कोई यह मान रहा है कि यह कोड गोल्फ है, इसलिए मैं इस हिसाब से चुनौती को टैग करूंगा (क्योंकि यह अन्यथा सभी मौजूदा उत्तरों को कुछ हद तक बेकार कर देगा)। यदि आप एक अलग जीत मानदंड चाहते हैं, तो आप एक नई चुनौती पोस्ट करने पर विचार कर सकते हैं।

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

Answer 1

जेली, 29 बाइट्स

-3 बाइट्स @JonathanAllan को धन्यवाद

कृपया , अगर कोई समस्या / कीड़े / त्रुटियां या बाइट्स हैं, तो मैं मुझे सूचित कर सकता हूं, मैं दस्तक दे सकता हूं!

“[(*)]”ṗµḟ”*œṣ⁾()Fœṣ⁾[]FµÐLÐḟ

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

पिछला समाधान मेरे पास था:

“[(*)]”ṗµḟ”*œṣ⁾()Fœṣ⁾[]FµÐL€Ṇ€Tị
“[(*)]”ṗµ¹ḟ”*œṣ⁾()Fœṣ⁾[]FµÐL€Ṇ€Tị
“[(*)]”ṗµ¹ḟ”*œṣ⁾()Fœṣ⁾[]FµÐL€Ṇ€×Jḟ0ị
“[(*)]”x⁸ṗ⁸Qµ¹ḟ”*œṣ⁾()Fœṣ⁾[]FµÐL€Ṇ€×Jḟ0ị
“[(*)]”x⁸ṗ⁸Qµ¹µḟ”*œṣ⁾()Fœṣ⁾[]FµÐL€Ṇ€×Jḟ0ị
“[(*)]”x⁸ṗ⁸Qµ¹µḟ”*œṣ⁾()Fœṣ⁾[]FµÐLµ€Ṇ€×Jḟ0ị

स्पष्टीकरण (एक विवरण में मेरा सबसे अच्छा प्रयास):

Input n
“[(*)]”ṗ-All strings composed of "[(*)]" of length n
µḟ”*    -Filter out all occurences of "*"
œṣ⁾()   -Split at all occurences of "()"
F       -Flatten
œṣ⁾[]   -Split at all occurences of "[]"
F       -Flatten
µÐL     -Repeat that operation until it gives a duplicate result
Ðḟ      -Filter

Comments

आप फ़िल्टरिंग का उपयोग करके तीन बाइट्स बचा सकते हैं ( “[(*)]”ṗµḟ”*œṣ⁾()Fœṣ⁾[]FµÐLÐḟ)

— जोनाथन एलन

Answer 2

प्रोलॉग, 69 बाइट्स

s-->[];e,s.
e-->"*";"(",s,")";"[",s,"]".
b(N,A):-length(A,N),s(A,[]).

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

उपरोक्त एक विधेय (एक फ़ंक्शन के समतुल्य) को परिभाषित करता है bजो यह देखने के लिए परीक्षण करता है कि क्या एक स्ट्रिंग की लंबाई दी गई है और यह एक "ब्रेस स्ट्रिंग" है जैसा कि प्रश्न में परिभाषित किया गया है। विशेष रूप से, यह प्रोलॉग के व्याकरण / रेगेक्स / पैटर्न-मैच समर्थन के माध्यम से करता है जो इस तरह की अभिव्यक्ति को परिभाषित करने के लिए कुछ अच्छा, छोटी चीनी देता है (जाहिर है यह मानक / पोर्टेबल है, लेकिन मैं मूल रूप से उत्तर लिखते समय इससे अनजान था और इस प्रकार। माना जाता है कि उत्तर केवल एक प्रोलॉग कार्यान्वयन पर काम करेगा; ऐसा लगता है कि यह प्रत्येक कार्यान्वयन पर काम करता है जो मानकों का अनुपालन करता है, हालांकि)। कार्यक्रम का अंग्रेजी में सीधे अनुवाद किया जा सकता है; पहले दो लाइनों कहते हैं कि "एक रों एक खाली स्ट्रिंग, या एक है ई एक के बाद एस , एक ईएक तारक, या एक है रों कोष्ठक में, या एक रों वर्ग कोष्ठक में "। तीसरी पंक्ति के रूप में व्याख्या की जा सकती है" ख की एन हो सकता है एक अगर एक लंबाई के साथ एक सूची है एन और एक एक है s एक अशक्त द्वारा पीछा किया स्ट्रिंग। "

मैंने लिखने के लिए कुछ ध्यान रखा s(और इस प्रकार b) ताकि वे प्रत्येक "ब्रेस स्ट्रिंग" से बिल्कुल एक तरह से मेल खाएं (जो कि कारण है sऔर दोनों eका अस्तित्व है, बजाय उन्हें एक विधेय में शामिल करने के)। यह उन दोनों को पूरी तरह से प्रतिवर्ती बनाता है; इस प्रकार bकिसी दिए गए लंबाई के सभी "ब्रेस स्ट्रिंग्स" उत्पन्न करने के लिए इस्तेमाल किया जा सकता है, परीक्षण के अलावा अगर एक स्ट्रिंग एक दी गई लंबाई का एक ब्रेस स्ट्रिंग है (यह एक ब्रेस की लंबाई का पता लगाने के लिए तीसरे तरीके के दौर का उपयोग किया जा सकता है स्ट्रिंग, लेकिन यह लगभग निश्चित रूप से ऑपरेशन का सबसे कम उपयोगी तरीका है)। कार्यान्वयन पुनरावर्ती है, उदाहरण के लिए, एक एस उत्पन्न करने के लिए , कोड सभी संभव ई उत्पन्न करेगा जो उत्पादन की आवश्यक लंबाई से अधिक नहीं है, और सभी संभव एस को जोड़ देंशेष स्थान में उनके लिए उपयुक्त है; क्योंकि मैंने तर्क की लंबाई अग्रिम में ( बी के भीतर ) निर्दिष्ट की थी , प्रोलॉग इंजन जानता है कि यह दी गई लंबाई से अधिक उत्पादन नहीं कर सकता है, जो पुनरावृत्ति को समाप्त करने की अनुमति देता है।

यहाँ ऑपरेशन में कार्यक्रम का एक उदाहरण है:

| ?- b(4,A),format("~s ",[A]),fail.
**** **() **[] *()* *(*) *[]* *[*] ()** ()() ()[] (*)* (**) (()) ([]) []** []() [][] [*]* [**] [()] [[]]

Comments

यह महसूस करता है कि यह निर्दिष्ट करने के लिए सिंटैक्स के लिए कुछ लागत होनी चाहिए कि क्या आप "फॉरवर्ड" या "बैकवर्ड" प्रोग्राम चलाना चाहते हैं। perl उस तरह की हर चीज के लिए 1 बाइट का भुगतान करता है

— Spear

ठीक है, आप एक नियम बना सकते हैं कि अंत में तर्क हमेशा रिटर्न मान हैं, फिर यह बताने के लिए तर्कों के क्रम को उल्टा करें कि आप किस तरह से कार्यक्रम चला रहे हैं। गोल्फिंग भाषाओं के लिए यह पता लगाना काफी आम है कि उन्हें आंशिक रूप से यह देखना चाहिए कि क्या उन्हें कोई इनपुट दिया गया है, और यह एक तुलनीय सिद्धांत है। सामान्य तौर पर, हालांकि, ऐसे नियम बनाना कठिन है जो हर संभव भाषा पर लागू होते हैं; रनिंग बिलियन जैसे lengthऔर appendकिसी भी तरह से भाषा का एक मौलिक हिस्सा है, और उपयोगकर्ता फ़ंक्शन अक्सर ऐसा ही करते हैं।

ओह, हम्म। मैंने माना कि आपके उदाहरण में कुछ संकेत थे जो प्रश्न में व्यवहार को ट्रिगर करते थे।

— स्पार्क

नहीं, यह पूरी तरह से है जिसके कारण तर्क दिए गए हैं। उपरोक्त कार्यक्रम में, मैं लिखता हूं length(A,N); यदि Nदिया गया है और Aनहीं है (जो तब होगा जब प्रोग्राम में अनुरोधित तरीके से विधेय का उपयोग किया जाता है), अज्ञात तत्वों से मिलकर lengthएक सूची उत्पन्न करेगा । किसी सूची की लंबाई को मापने के लिए उपयोग करना आमतौर पर अधिक सामान्यतः उपयोग किया जाता है (हालांकि "बैकवर्ड" का उपयोग करना प्रोलॉग प्रोग्रामिंग में काफी आम है)। अधिकांश विधेय एक ही तरीके से काम करने का अंत करते हैं (एकमात्र कारण यह नहीं है कि यदि उन्हें उलटने का प्रयास एक अनंत लूप का निर्माण करेगा, जो काफी सामान्य है)। ANlength

@ एआईएस 523 -->और डीसीजी सामान्य तौर पर मानक आईएसओ प्रोलॉग हैं ।

— घातक

Answer 3

हास्केल, 101 94 बाइट्स

7 बाइट्स जर्ब द्वारा बचाए गए!

b 0=[""]
b n=[x++y|k<-[1..n],x<-u k,y<-b$n-k]
u 1=["*"]
u n=[a:s++b|s<-b$n-2,a:b<-["()","[]"]]

लगभग सरल, परिभाषा का पालन, लेकिन ""मामले चले गए।

उपयोग:

*Main> map b [0..3]
[[""],["*"],["**","()","[]"],["***","*()","*[]","()*","[]*","(*)","[*]"]]
*Main> length $ b 10
21595

(दूसरी गणना धीमी मशीन पर एक सेकंड से भी कम समय लेती है।)

मैं एक और दृष्टिकोण के परिणाम को भी साझा करना चाहूंगा, जिसके साथ मैं कार्य करने के बारे में सोच रहा था। यह स्ट्रिंग्स की सूचियों की एक सूची b को परिभाषित करता है b!!nजिसमें लंबाई के सभी ब्रेस-स्ट्रिंग्स शामिल हैं n। इसी प्रकार, u!!nआकार के सभी परमाणु होते हैं n-1। एक अच्छी बात यह है कि कोड किसी भी संख्या का उपयोग नहीं कर रहा है। यह पूरी तरह से गोल्फ नहीं है: uऔर इनलेट iकिया जा सकता है, और यह निश्चित रूप से कुछ अन्य गोल्फिंग अवसरों को याद करता है। दुर्भाग्य से, ऐसा नहीं लगता है कि इसे पहले संस्करण की तुलना में छोटा किया जा सकता है, लेकिन यह और length $ b !! 10भी तेज़ है।

b=[""]:b%u
u=["*"]:map i b
i=concatMap(\s->['(':s++")",'[':s++"]"])
(b:c)%f=zipWith(++)[[x++y|x<-b,y<-e]|e<-f]([]:c%f)

Comments

के साथ दो बाइट्स सहेजें b$n-kऔर b$n-2। इसके अलावा, अंतिम पंक्ति पर आप कर सकते हैं a:b<-["()","[]"]और वापस लौट सकते हैं a:s++b।

— जर्बर्ग

ओह, मैं उपयोग करना चाहता था, ["()","[]"]लेकिन यह नहीं देख सका कि इसके साथ कोड आकार कैसे सुधारें। धन्यवाद!

— क्रिश्चियन सेवर्स

Answer 4

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

#<>""&/@Select[Characters@"*([)]"~Tuples~#,(#/."*"->Nothing//.{a___,"(",")",b___}|{a___,"[","]",b___}:>{a,b})=={}&]&

व्याख्या

Characters@"*([)]"

स्ट्रिंग के पात्रों का पता लगाएं "*([)]", दे रहा है List {"*", "(", "[", ")", "]"}।

... ~Tuples~#

लंबाई के साथ उपरोक्त सूची के tuples का पता लगाएं n।

(#/."*"->Nothing//.{a___,"(",")",b___}|{a___,"[","]",b___}:>{a,b})=={}&

ट्यूलल संतुलित है या नहीं, यह जानने के लिए मल का कार्य:

#/."*"->Nothing

"*"इनपुट में सभी को हटा दें ।

... //.{a___,"(",")",b___}|{a___,"[","]",b___}:>{a,b}

बार बार के सभी लगातार घटनाओं को हटाना "("और ")"या "["और "]"जब तक इनपुट नहीं बदलता है।

... =={}

जांचें कि क्या परिणाम खाली है List।

Select[ ... , ... ]

Trueबुलियन फ़ंक्शन लागू होने पर देने वाले ट्यूपल्स का पता लगाएं ।

#<>""&/@

प्रत्येक Listवर्ण को Strings में बदलें ।

Comments

कुछ अप्रत्याशित रूप से, {x=a___,"(",")",y=b___}|{x,"[","]",y}काम करने लगता है।

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

Answer 5

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

n=input()
for i in range(5**n):
 try:s=','.join('  "00([*])00"  '[i/5**j%5::5]for j in range(n));eval(s);print s[1::4]
 except:1

पेंच पुनरावर्ती रेग्जेस - हम पायथन के पार्सर का उपयोग कर रहे हैं! यह सत्यापित करने के लिए, उदाहरण के लिए, *(**[])*एक ब्रेस-स्ट्रिंग है, हम निम्नलिखित कार्य करते हैं:

1. एक तार की तरह बनाएं "*", (0,"*","*", [0,0] ,0) ,"*", जहां चार का हर दूसरा चरित्र ब्रेस-स्ट्रिंग्स से एक चरित्र है, और शेष अक्षर इस संभावित पायथन अभिव्यक्ति को बनाने के लिए गोंद हैं ।

2. eval यह।

3. यदि वह कोई त्रुटि नहीं देता है, तो प्रिंट करें s[1::4](ब्रेस-स्ट्रिंग वर्ण)।

गोंद पात्रों इसलिए उठाया जाता है कि स्ट्रिंग मैं बनाने के लिए एक वैध अजगर अभिव्यक्ति तभी हर दूसरे चरित्र चार पैदावार एक वैध ब्रेस-स्ट्रिंग से बाहर ले जा रहा है।

Answer 6

PHP, 149 बाइट्स

for(;$argv[1]--;$l=$c,$c=[])foreach($l?:['']as$s)for($n=5;$n--;)$c[]=$s.'*()[]'[$n];echo join(' ',preg_grep('/^((\*|\[(?1)]|\((?1)\))(?1)?|)$/',$l));

अच्छे पुराने का उपयोग करता है सभी संभव और फिर फ़िल्टर विधि। उपयोग की तरह:

php -r "for(;$argv[1]--;$l=$c,$c=[])foreach($l?:['']as$s)for($n=5;$n--;)$c[]=$s.'*()[]'[$n];echo join(' ',preg_grep('/^((\*|\[(?1)]|\((?1)\))(?1)?|)$/',$l));" 4

Answer 7

अजगर, 134 बाइट्स

from itertools import*
lambda n:[x for x in map(''.join,product('*()[]',repeat=n))if''==eval("x"+".replace('%s','')"*3%('*',(),[])*n)]

repl.it

फ़ंक्शन जो लंबाई के मान्य स्ट्रिंग्स की सूची देता है n।
फार्म सभी लंबाई nपात्रों में से tuples *()[], उन्हें प्रयोग तार में मिलती है map(''.join,...)और उन लोगों के लिए फिल्टर है कि "जोड़े" को निकाल कर कोष्ठक संतुलित है "*", "()"और "[]"बदले में nबार और जाँच कि परिणाम एक खाली स्ट्रिंग है ( nबार overkill, विशेष रूप से के लिए है "*"लेकिन गोल्फर है)।

Answer 8

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

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

.+
$*
+%1`1
*$'¶$`($'¶$`)$'¶$`[$'¶$`]
%(`^
$';
)+`(\[]|\(\)|\*)(?=.*;)|^;

A`;

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

व्याख्या

मैं लंबाई 5 के सभी संभावित तार पैदा कर रहा हूं और फिर मैं अमान्य लोगों को फ़िल्टर करता हूं।

.+
$*

यह 1अंक के रूप में उपयोग करते हुए, इनपुट को एकरी में रूपांतरित करता है ।

+%1`1
*$'¶$`($'¶$`)$'¶$`[$'¶$`]

यह बार-बार ( +) 1प्रत्येक पंक्ति में पहले ( ) एक को इस तरह से प्रतिस्थापित करता है %कि यह पंक्ति की पांच प्रतियां बनाता है, प्रत्येक संभावित चरित्र के लिए एक। यह उपसर्ग और प्रत्यय प्रतिस्थापन का उपयोग करके, $`और $'प्रत्येक पंक्ति के शेष का निर्माण करने के लिए किया जाता है।

यह लूप बंद हो जाता है जब बदलने के लिए 1s नहीं होते हैं। इस बिंदु पर हमें लंबाई के सभी संभावित तार मिले हैं N, प्रत्येक पंक्ति पर एक।

%(`^
$';
)+`(\[]|\(\)|\*)(?=.*;)|^;

इन दो चरणों को अलग-अलग प्रत्येक पंक्ति के लिए निष्पादित किया जाता है ( %)। पहला चरण केवल ;दो प्रतियों को अलग करने के लिए , लाइन को डुप्लिकेट करता है ।

दूसरा चरण एक और लूप ( +) है, जो बार-बार हटाता है [], ()या *स्ट्रिंग की पहली प्रति से, या लाइन की शुरुआत में एक अर्धविराम निकालता है (जो स्ट्रिंग के पूरी तरह से गायब हो जाने के बाद ही संभव है)।

A`;

वैध तार वे हैं जिनके सामने अब अर्धविराम नहीं है, इसलिए हम बस उन सभी पंक्तियों ( A) को छोड़ देते हैं जिनमें अर्धविराम होता है।

Comments

मैं 5 इनपुट के साथ onliny की कोशिश की: ठीक है। इनपुट 6 के साथ मुझे एक त्रुटि पृष्ठ मिला

— edc65

@ edc65 मेरे लिए काम करता है, लेकिन निश्चित रूप से यह दृष्टिकोण बिल्कुल कुशल नहीं है, इसलिए इसमें कुछ सेकंड लगते हैं। आप किस प्रकार के त्रुटि पृष्ठ का मतलब है?

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

इनपुट 5: 3 सेकंड में उत्तर। इनपुट 6: 7 सेकंड के बाद, आउटपुट बॉक्स के अंदर, मुझे अपने प्रॉक्सी से जो शायद एक त्रुटि पृष्ठ है, उसका html स्रोत मिलता है। यदि यह एक टाइमआउट है तो यह बहुत कम समय समाप्त हो गया है ... मैं इनपुट 6 के लिए एक सही परीक्षण केस प्राप्त करने की कोशिश कर रहा था, क्योंकि मुझे मेरा जवाब इनपुट 5 तक ठीक लगता है, लेकिन 6 या अधिक के लिए गलत है

— edc65

@ edc65 यह निश्चित रूप से 7 सेकंड से अधिक समय लेता है, और TIO का टाइमआउट एक मिनट है। मैं त्रुटि आप का वर्णन कभी नहीं देखा है, में इस लाने के लायक हो सकता है TIO चैट (या आप चाहें तो gitter पर या GitHub )। संदर्भ आउटपुट के रूप में, यहां मुझे इनपुट 6 के लिए क्या मिलता है: pastebin.com/WmmPPmrc (इनपुट 7 में एक मिनट से अधिक समय लगता है।)

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

Answer 9

पायथन 3.5, 146 बाइट्स

import re;from itertools import*;lambda f:{i for i in map(''.join,permutations("[()]*"*f,f))if re.fullmatch("(\**\[\**\]\**|\**\(\**\)\**)*|\**",i)}

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

print(<Function Name>(<Integer>))

के पायथन सेट को आउटपुट करता हैइनपुट लंबाई के सभी संभव ब्रेस-स्ट्रिंग्स का प्रतिनिधित्व करते हुए अनियंत्रित तारों के ।

उदाहरण के लिए, उपरोक्त फ़ंक्शन को नाम दिया गया है G , प्रेरक G(3)निम्नलिखित उत्पादन में परिणाम होगा:

{'[*]', '*()', '*[]', '(*)', '***', '[]*', '()*'}

यह ऑनलाइन की कोशिश करो! (Ideone)

---

हालाँकि, अगर, मेरी तरह, आप वास्तव में बिल्ट-इन का उपयोग करके चीजों को सरल बनाने के प्रशंसक नहीं हैं, तो यहाँ मेरा अपना मूल उत्तर है , क्रमपरिवर्तन खोजने के लिए किसी भी बाहरी पुस्तकालयों का उपयोग नहीं करना , और वर्तमान में 288 237 बाइट पर खड़ा है :

import re;D=lambda f:f and"for %s in range(%d)"%(chr(64+f),5)+D(f-1)or'';lambda g:[i for i in eval('["".join(('+''.join('"[()]*"['+chr(o)+'],'for o in range(65,65+g))+'))'+D(g)+']')if re.fullmatch("(\**\[\**\]\**|\**\(\**\)\**)*|\**",i)]

फिर, प्रतिस्पर्धात्मक उत्तर की तरह, यह एक मेमने के कार्य के रूप में है और इसलिए इसे प्रारूप में भी कहा जाना चाहिए

print(<Function Name>(<Integer>))

और एक अजगर आउटपुट सूची के अवर्गीकृत इनपुट लंबाई के सभी ब्रेस-स्ट्रिंग्स का प्रतिनिधित्व करने वाले स्ट्रिंग्स के । उदाहरण के लिए, यदि लैंबडा के रूप में आमंत्रित किया जाना था G(3), तो इस बार आउटपुट निम्न होगा:

['*()', '(*)', '*[]', '[*]', '()*', '[]*', '***']

इसके अलावा, यह भी मेरे अन्य उत्तर की तुलना में बहुत तेज है , जो 11लगभग 115 सेकंड में लंबाई के सभी ब्रेस-स्ट्रिंग्स का पता लगाने में सक्षम है , 10लगभग 19 सेकंड में लंबाई वाले 9, लगभग 4 सेकंड में लंबाई वाले और लंबाई 8में उन मेरी मशीन पर लगभग 0.73 सेकंड , जबकि मेरे प्रतिस्पर्धात्मक उत्तर में बहुत कुछ है एक इनपुट के लिए ११५ सेकंड से समय है6 ।

यह ऑनलाइन की कोशिश करो! (Ideone)

Answer 10

05AB1E, 23 बाइट्स

…[(*.∞sãʒ'*м„()„[]‚õ:õQ

प्रश्न पोस्ट किए जाने के बाद इनमें से कुछ विशेषताएं लागू हो सकती हैं। किसी भी सुझाव का स्वागत है!

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

कैसे?

…[(* - the string '[(*'
.∞ - intersected mirror, '[(*'=>'[(*)]'
s - swap the top two items, which moves the input to the top
ã - cartesian power
ʒ ...  - filter by this code:
  '*м      - remove all occurrences of '*'
  „()„[]‚  - the array ["()","[]"]
  õ        - the empty string ""
  :        - infinite replacement (this repeatedly removes "()", "[]", and "*" from the string
  õQ       - test equality with the empty string

Comments

मैं 05AB1E नहीं जानता, लेकिन *यह भी हटाने की सरणी में नहीं हो सकता है ? और õQचेक को किसी चीज़ की तरह नहीं बदला जा सकता है?

— फल

पहला सुझाव किसी भी बाइट को नहीं बचाएगा: '*м„()„[]‚õ:बनाम „()„[]‚'*«õ:(परीक्षण नहीं किया गया), क्योंकि 3 मूल्यों AFAIK को संक्षिप्त करने के लिए कोई आदेश नहीं है। दूसरा काम नहीं करेगा क्योंकि कोई भी ऐसा नहीं है जो एक स्ट्रिंग, AFAIK पर काम करेगा। (जहाँ AFAIK "जहाँ तक मैं जानता हूँ" का प्रतिनिधित्व करता है)

— ज़ाचरी