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

Question

एक "ट्रिपल ब्रैकेट" (जो मैंने इस चुनौती के लिए बनाया है) निम्नलिखित में से एक है:

(...+...)
[...:...]
{...|...}
<...-...>

एक संतुलित ट्रिपल ब्रैकेट स्ट्रिंग (शॉर्ट के लिए बीटीबीएस) या तो एक खाली स्ट्रिंग है, दो बीटीबीएस समेटे हुए हैं, या ...बीटीबीएस के साथ प्रतिस्थापित प्रत्येक के साथ उपरोक्त ट्रिपल ब्रैकेट में से एक है।

आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो यह जांचता है कि क्या एक स्ट्रिंग जिसमें केवल (+)[:]{|}<->संतुलित है। सबसे छोटा कोड जीतता है।

उदाहरण

आपके कार्यक्रम को निम्न तार के लिए सत्य लौटना चाहिए:

(+)(+)(+)
[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)
<<<<<<<<<<<<->->->->->->->->->->->->
{|(+[:<-{|(+[:<->])}>])}
[[[:]:[:]]:[[:]:[:]]]
{[:](+)|<->{|}}[(+)<->:{|}(+)]

आपके कार्यक्रम को निम्नलिखित तार के लिए मिथ्या लौटना चाहिए:

:[
<|>
(+(+)
[:][:](+[[:]):]
{|{|{|(+{|{|{|}}}}}+)}[:]{|}
{{||}}
<<->-<->-<->>
[(+):((+)+)+(+(+))]
<<<<<->->->->->->

Comments

है (|)मान्य। मुझे ऐसा नहीं लगता, लेकिन मुझे यकीन नहीं है

— रोमन ग्रैफ़

@ RomanGräf नहीं, झूठे <|>उदाहरणों के रूप में।

— jimmy23013

Answer 1

जाप, 25 बाइट्स

!Ue"%(%+%)|%[:]|\{%|}|<->

इसे ऑनलाइन टेस्ट करें!

eतार पर एक पुनरावर्ती-प्रतिस्थापित कार्य है। दूसरा पैरामीटर खाली स्ट्रिंग को डिफॉल्ट करता है, जिसका अर्थ है कि यह जाप रेगेक्स "%(%+%)|%[:]|\{%|}|<->"(नियमित रूप से, /\(\+\)|\[:]|{\|}|<->/) में मिलान को हटा देता है । यह संतुलित ट्रिपल स्ट्रिंग्स के लिए एक खाली स्ट्रिंग और गैर-संतुलित के लिए एक गैर-रिक्त स्ट्रिंग देता है, इसलिए सही वापसी मूल्य इस का तार्किक नहीं है।

Answer 2

जावास्क्रिप्ट (ईएस 6), 77 58 57 56 बाइट्स

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

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

f=s=>s==(s=s.replace(/\(\+\)|\[:]|{\|}|<->/,''))?!s:f(s)

console.log("Testing truthy values");
console.log(f("(+)(+)(+)"));
console.log(f("[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)"));
console.log(f("<<<<<<<<<<<<->->->->->->->->->->->->"));
console.log(f("{|(+[:<-{|(+[:<->])}>])}"));
console.log(f("[[[:]:[:]]:[[:]:[:]]]"));
console.log(f("{[:](+)|<->{|}}[(+)<->:{|}(+)]"));

console.log("Testing falsy values");
console.log(f(":["));
console.log(f("<|>"));
console.log(f("(+(+)"));
console.log(f("[:][:](+[[:]):]"));
console.log(f("{|{|{|(+{|{|{|}}}}}+)}[:]{|}"));
console.log(f("{{||}}"));
console.log(f("<<->-<->-<->>"));
console.log(f("[(+):((+)+)+(+(+))]"));
console.log(f("<<<<<->->->->->->"));

Comments

रेटिना में एक ही विचार 26 बाइट्स हैं (पहली पंक्ति सिर्फ इसे एक परीक्षण सूट बनाती है): retina.tryitonline.net/…

— मार्टिन

और 39 प्रति पर्ल के साथ perl -lpe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=!$_':।

— दादा

@ दादा बीटीबीएस पर विचार करेंगे 0। इसके बजाय 38 का उपयोग करें:perl -pe 's/<->|\(\+\)|{\|}|\[:]//&&redo;$_=/^$/'

— टन हास्पेल

@ टोनहॉस्ट ने ऐसा नहीं सोचा था, वास्तव में .. इसे इंगित करने के लिए धन्यवाद! (जिस तरह से आप चाहें तो इसे बेझिझक पोस्ट कर सकते हैं, या कम से कम मेरी वजह से वापस नहीं पकड़ सकते हैं)

— दादा

उस एस / एस मिश्रण थोड़ा भ्रमित था, शायद f=s=>s==(s=s.replace(...))?!s:f(s)?

— नील

Answer 3

sed, 28 27 बाइट्स

:
s#(+)\|\[:]\|{|}\|<->##
t

sed में सत्य / मिथ्या की अवधारणा नहीं है, इसलिए मैं एक रिक्त स्ट्रिंग सत्य और एक गैर-रिक्त स्ट्रिंग मिथ्या पर विचार कर रहा हूं। यह जाँच करता है कि क्या हम सशर्त पर विचार करते हैं /^$/।

1 बाइट को बंद करने के लिए @ नील को धन्यवाद!

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

Comments

एक बार के लिए, BRE वास्तव में एक फायदा है ।

— डेनिस

क्या आपको जरूरत है \]या ]पर्याप्त है?

— नील

मैं नही। धन्यवाद!

— डेनिस

Answer 4

पायथन, 77 बाइट्स

lambda s:eval("s"+".replace('%s','')"*4%('(+)','[:]','{|}','<->')*len(s))==''

Arnauld के प्रतिस्थापन विचार का उपयोग करता है । एक लंबी स्ट्रिंग की तरह उत्पन्न करता है और मूल्यांकन करता है

s.replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','').replace('(+)','').replace('[:]','').replace('{|}','').replace('<->','')

सभी ब्रैकेट प्रकारों को बदलने के बीच में चक्र करने के लिए। फिर, जाँचता है कि परिणाम खाली स्ट्रिंग है या नहीं।

Answer 5

मैथेमेटिका, 55 बाइट्स

StringDelete["(+)"|"[:]"|"{|}"|"<->"]~FixedPoint~#==""&

अनाम फ़ंक्शन। इनपुट और रिटर्न के रूप में Trueया Falseआउटपुट के रूप में एक स्ट्रिंग लेता है । ऐसा करने के लिए मानक विधि का उपयोग करता है।

Answer 6

ग्रिम , 39 बाइट्स

e`\(_\+_\)|\[_\:_\]|\{_\|_\}|\<_\-_\>v*

इसे ऑनलाइन आज़माएं! दुख की बात है कि TIO संस्करण अधिकांश परीक्षण मामलों में मेमोरी से बाहर चला जाता है।

व्याख्या

यहां कुछ भी नहीं फैंसी। _पूरे पैटर्न के लिए आशुलिपि है, और v*जैसा है *, लेकिन कम पूर्वता के साथ।

e`                                       Match entire input against this pattern:
  \(_\+_\)                               '(', match of _, '+', match of _, ')'
          |                              or
           \[_\:_\]|\{_\|_\}|\<_\-_\>    same for the other bracket types
                                     v*  repeated 0-∞ times

Answer 7

जे, 48 बाइट्स

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_

दूसरों की तरह, यह भी अर्नुलद की विधि पर आधारित है ।

प्रयोग

   f =: a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_
   f '(+)(+)(+)'
1
   f '[[[:]:]:(+(+))]{<->|<(+)->[:]}(+)'
1
   f '<<<<<<<<<<<<->->->->->->->->->->->->'
1
   f '<|>'
0
   f '[:][:](+[[:]):]'
0
   f '{|{|{|(+{|{|{|}}}}}+)}[:]{|}'
0

व्याख्या

a:=([:delstring&.>/'(+)';'[:]';'{|}';'<->';])^:_  Input: string S
   (                                        )^:_  Repeat until convergence
                                         ]          Get S
                 '(+)';'[:]';'{|}';'<->';           Append to ['(+)', '[:]', '{|}', '<->']
    [:delstring&.>/                                 Reduce right-to-left by deleting
                                                    occurrences of each string on the
                                                    left from the right
                                                    Return the final string as the new S
a:=                                               Test if the final value of S is empty

Answer 8

स्काला, 96 बाइट्स

def&(s:String):Any={val t=s.replaceAll(raw"\(\+\)|\[:]|\{\|}|<->","")
if(t==s)t.size<1 else&(t)}

यह मूल रूप से अन्य उत्तरों के समान विचार है, लेकिन कुछ स्कैला बॉयलरप्लेट के साथ है।

दूसरों से विचारों को चुराए बिना (188 बाइट्स):

import scala.util.parsing.combinator._
val a = new RegexParsers{def r:Parser[_]="("~r~"+"~r~")"|"["~r~":"~r~"]"|"{"~r~"|"~r~"}"|"<"~r~"-"~r~">"|""
def!(s:String)= !parseAll(r,s).isEmpty}!_

Answer 9

पिप , 26 बाइट्स

L#aaR:"(+)[:]{|}<->"<>3x!a

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

लूप्स (ए) बार, खाली ट्रिपल ब्रैकेट ( "(+)[:]{|}<->"<>3, जहां <>"समूह" ऑपरेटर, => ["(+)"; "[:]"; "{|}"; "<->"]) के सभी आवृत्तियों को खाली स्ट्रिंग के साथ प्रतिस्थापित किया जाता है ( x)। यह कई पुनरावृत्तियों overkill है, लेकिन यह हमेशा पर्याप्त से अधिक होगा पूरी तरह से कुछ भी नहीं करने के लिए पूरी तरह से गठित ट्रिपल ब्रैकेट को कम करने के लिए। लूप पूरा होने के बाद, आउटपुट !a: 0यदि aसत्य है (अभी भी कुछ अक्षर हैं), 1यदि aफाल्सी (खाली) है।