क्या कोष्ठक पूरी तरह से मेल खाते हैं?

Question

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो ब्रैकेट्स की एक स्ट्रिंग लेता है और आउटपुट करता है कि क्या स्ट्रिंग पूरी तरह से मेल खाती है या नहीं। आपके कार्यक्रम को एक सत्य या गलत मूल्य छापना चाहिए , और IO किसी भी उचित प्रारूप में हो सकता है ।

नियम और परिभाषाएँ:

• इस चुनौती के प्रयोजन के लिए, एक "ब्रैकेट" इन पात्रों में से किसी प्रकार है: ()[]{}<>।

• ब्रैकेट की एक जोड़ी को "मिलान" माना जाता है यदि उद्घाटन और समापन ब्रैकेट सही क्रम में हैं और उनके अंदर कोई वर्ण नहीं है, जैसे कि

  ()
  []{}
  

  या अगर इसके अंदर का हर सबमेलमेंट भी मैच हो जाए।

  [()()()()]
  {<[]>}
  (()())
  

  घनीभूत कई परतों को भी घना किया जा सकता है।

  [(){<><>[()]}<>()]
  <[{((()))}]>
  

• एक स्ट्रिंग माना जाता है "पूरी तरह से मिलान" अगर और केवल अगर:

  1. हर एक पात्र एक कोष्ठक है,

  2. ब्रैकेट की प्रत्येक जोड़ी में सही उद्घाटन और समापन ब्रैकेट और सही क्रम में है, और

  3. प्रत्येक ब्रैकेट का मिलान किया जाता है।

• आप मान सकते हैं कि इनपुट में केवल मुद्रण योग्य ASCII होगा ।

परीक्षण IO

यहां कुछ इनपुट दिए गए हैं जो एक सत्य मान लौटना चाहिए:

()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]

और यहाँ कुछ आउटपुट दिए गए हैं, जो एक मिथ्या मूल्य वापस करना चाहिए:

(               Has no closing ')'
}{              Wrong order
(<)>            Each pair contains only half of a matched element
(()()foobar)    Contains invalid characters
[({}<>)>        The last bracket should be ']' instead of '>'
(((()))         Has 4 opening brackets, but only 3 closing brackets.

हमेशा की तरह, यह कोड-गोल्फ है, इसलिए मानक कमियां लागू होती हैं, और बाइट्स जीत में सबसे छोटा जवाब होता है।

Comments

सम्बंधित।

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

संभावित करीबी मतदाताओं पर ध्यान दें: मैंने जो चुनौती दी है, उसमें ब्रैकेट प्रकारों के लिए प्राथमिकता क्रम भी शामिल है, ताकि वे एक मनमाने ढंग से आदेश में नेस्टेड न हो सकें। मुझे लगता है कि यह पर्याप्त रूप से अलग बनाता है।

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

है [}एक मैच? और यदि नहीं, तो इसे इन नियमों द्वारा कहां रखा गया है?

— user207421

@ ईजेपी नहीं, यह नहीं है। Each pair of brackets has the correct opening and closing bracket and in the right order.

— DJMcMayhem

मैं ब्रैकेट

— leo

Answer 1

05AB1E , 19 बाइट्स

इनपुट उद्धरणों में दिया गया है । कोड:

"[](){}<>"2÷)"":g2Q

अच्छी तरह से बकवास, बहुत सारे बग और अनइम्प्लीमेंटेड फीचर्स पाए गए। स्पष्टीकरण:

"[](){}<>"           # Push this string
          2÷         # Split into pieces of two
            )        # Wrap it into an array (which should not be needed)
             ""      # Push an empty string
               :     # Infinite replacement

यह वास्तव में एक मुश्किल हिस्सा है। स्यूडोकोड में यह कैसा दिखता है:

input().replace(['[]', '()', '{}', '<>'], "")

यह इस भाग को 05AB1E कोड से कवर करता है :

if type(b) is list:
    temp_string = temp_string_2 = str(a)
    while True:
        for R in b:
            temp_string = temp_string.replace(R, c)
        if temp_string == temp_string_2:
            break
        else:
            temp_string_2 = temp_string
    stack.append(temp_string)

जैसा कि आप देख सकते हैं, यह अनंत प्रतिस्थापन है (जब तक स्ट्रिंग अब और नहीं बदलती है)। इसलिए, मुझे एक पाश में प्रतिस्थापन स्थापित करने के बारे में चिंता करने की ज़रूरत नहीं है, क्योंकि यह पहले से ही निर्मित है। उसके बाद:

                g    # Take the length of the final string
                 2Q  # Check if equal with 2 (which are the quotes at the end)

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! (थोड़ा संशोधित क्योंकि उपरोक्त संस्करण को हटा दिया गया है)।

Comments

अच्छी तरह से गोल्फ!

— सैम्युक

क्या इससे पहले õजोड़ा गया था?

— ज़ाचारि

@ Zacharý हां, यह सही है

— अदनान

Answer 2

ब्रेन-फ्लैक , 1101, 1085 , 981 बाइट्स

{(<(({}))((((()()()()()){}){}){})({}[{}]<(())>){((<{}{}>))}{}>{({}<>)(<>)}{}<(({
}))((((()()()()()){}){}){}())({}[{}]<(())>){((<{}{}>))}{}>{({}<>)({}[{}](<()>)){
{}{}(<(())>)}{}{<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))(((((()()()()()){}){})){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()(<>)}{}<(({}))(((((()()()()()){}){})(
)){}{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((()()()){}){}()){({}[()])}{})({}[{}]<(()
)>){((<{}{}>))}{}>{<({}()()<>)>()(<>)}{}<(({}))((((((()()()()()){})){}{}())){}{}
)({}[{}]<(())>){((<{}{}>))}{}>{<({}()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{<>{{
}}<>{{}}((<()>))}{}(<>)}{}<(({}))((((((()()()()()){}){}){}())){}{})({}[{}]<(())>
){((<{}{}>))}{}>{<({}()()()<>)>()(<>)}{}<(({}))((((((()()()()()){}){}){}())()){}
{})({}[{}]<(())>){((<{}{}>))}{}>{<({}()()()<>)>()({}[{}](<()>)){{}{}(<(())>)}{}{
<>{{}}<>{{}}((<()>))}{}(<>)}{}<{}>[()]){<>{{}}(<()>)<>{{}}(<()>)}{}}<>([]<>)({}<
(())>){((<{}{}>))}{}

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

यह स्रोत कोड की 980 बाइट्स है, और ASCII इनपुट (लेकिन दशमलव आउटपुट) की अनुमति देने +1वाले -aध्वज के लिए

यह एक ऐसा उत्तर है जिसे मैं बहुत लंबे समय से लिखना चाहता हूं । कम से कम 6 महीने। मैंने इसे पोस्ट करने का इंतजार किया क्योंकि मुझे पता था कि इस चुनौती का जवाब देना ब्रेन-फ्लैक में अतिरिक्त मेहनत होगी। लेकिन यह एक बहुत महत्वपूर्ण कारण के लिए इसके लायक है: स्रोत कोड स्वयं एक सत्य इनपुट है, जो इस भाषा का संपूर्ण बिंदु है।

और जैसा कि मैंने यहां लिखा है , इस सवाल ने मुझे दिमागी तौर पर लिखने के लिए प्रेरित किया।

कुछ ही समय बाद मैंने लिखा कि क्या कोष्ठक पूरी तरह से मेल खाते हैं?, इसने मुझे आश्चर्य में डाल दिया कि आप केवल मिलान किए गए कोष्ठक के साथ कितनी जानकारी संग्रहीत कर सकते हैं। एक बात जो मेरे सामने थी, वह यह थी कि भले ही आपके पास केवल 4 "परमाणु" प्रकार के हों:

(){}[]<>

आपके पास वास्तव में जानकारी देने के लिए 8 इकाइयाँ हैं, क्योंकि इनमें से प्रत्येक ब्रैकेट प्रकार खाली हो सकता है, या बीच में अन्य कोष्ठक हो सकते हैं, जो मूलभूत रूप से सूचना के अलग-अलग टुकड़े हैं। इसलिए, मैंने एक ऐसी भाषा लिखने का फैसला किया, जो केवल मिलान किए गए कोष्ठक के लिए अनुमति देता है, और जहां खाली कोष्ठक उनके अंदर अन्य कोष्ठक के साथ कोष्ठक की तुलना में कुछ अलग करते हैं।

इस जवाब को लिखने में लगभग दो घंटे लगे। मैं मानता हूँ कि यह बहुत खराब गोल्फ है, अधिकतर क्योंकि प्रत्येक ब्रैकेट प्रकार के लिए बहुत सारे कोड दोहराए जाते हैं। लेकिन मैं ज्यादातर हैरान हूं कि मैं एक जवाब लिखने में सक्षम था, विशेष रूप से यह देखते हुए कि ब्रेन-फ्लैक है

उपयोग करने के लिए दर्दनाक होने के लिए डिज़ाइन किया गया एक न्यूनतावादी एसोलांग

मैं इसे बाद में नीचे गिराने का प्रयास करने जा रहा हूं, लेकिन मैं इसे वैसे भी बाहर निकालना चाहता था।

मेरे पास एक विस्तृत विवरण है, लेकिन यह लगभग 6 हजार वर्ण लंबा है, इसलिए मुझे लगता है कि इस उत्तर में पूरी बात चिपकाना बुद्धिमानी नहीं होगी। आप चाहें तो इसके माध्यम से यहां पढ़ सकते हैं। मैं यहां एक छोटी व्याख्या जोड़ूंगा।

मूल विचार यह है कि हम स्टैक पर प्रत्येक वर्ण के लिए निम्न चरणों को दोहराते हैं:

• हम प्रत्येक वर्ण की जाँच करते हैं कि यह किसी ब्रैकेट से मेल खाता है या नहीं। यदि यह एक प्रारंभिक ब्रैकेट है, तो हम निम्नलिखित मैपिंग के अनुसार दूसरे स्टैक पर एक संख्या को धक्का देते हैं:

  ( = 1
  < = 2
  [ = 3
  { = 4
  

• फिर हम यह देखने के लिए जांचते हैं कि क्या यह किसी क्लोजिंग ब्रैकेट से मेल खाता है। यदि ऐसा होता है, तो हम ब्रैकेट खोलने के लिए वैकल्पिक स्टैक पर समान संख्या को धक्का देते हैं। फिर , हम जाँचते हैं कि क्या शीर्ष दो संख्याएँ समान हैं। यदि वे हैं, तो दोनों पॉप हो जाते हैं और कार्यक्रम सामान्य रूप से जारी रहता है। यदि वे नहीं हैं, तो हम दोनों स्टैक (लूपिंग को रोकने के लिए) को साफ़ करते हैं और वैकल्पिक स्टैक पर एक धक्का देते हैं। यह अनिवार्य रूप से एक "ब्रेक" बयान है।

• 8 ब्रैकेट प्रकारों की जांच करने के बाद, हम लूप के माध्यम से इस रन के मूल्य को धक्का देते हैं। चूंकि हम इसका अधिकांश भाग शून्य कर देते हैं, केवल स्निपेट जिनका कोई मूल्य होता है, वे सशर्त हैं जब हम कोष्ठक के खिलाफ तुलना करते हैं। इसलिए यदि किसी ब्रैकेट का मिलान किया जाता है, तो पूरे लूप का मान 1 होता है। यदि उनमें से किसी ने भी नहीं किया है, तो पूरे लूप का मान 0. होता है। इस स्थिति में, हम दोनों स्टैक्स को साफ कर देंगे और वैकल्पिक स्टैक पर 0 दबा देंगे। फिर, यह एक "ब्रेक" बयान की तरह है।

इसके बाद मुख्य लूप चल रहा है, बाकी काफी सरल है। हम (खाली) मुख्य स्टैक पर हैं, और यदि वे नहीं थे, तो वैकल्पिक स्टैक खाली है (यदि कोष्ठक मिलान किए गए थे) या गैर-खाली। तो हम इसे चलाते हैं:

#Toggle to the alternate stack
<>

#Push this stack-height onto main-stack
([]<>)

#Logical not
({}<(())>){((<{}{}>))}{}

यह मुख्य-स्टैक पर 0 या 1 को धक्का देगा, और जब प्रोग्राम समाप्त होता है, तो इसे स्पष्ट रूप से मुद्रित किया जाता है।

---

• एक अच्छे स्टैक-क्लीन "बराबर" और "लॉजिकल नॉट " स्निपेट के साथ आने के लिए, और नियमित रूप से उपयोगी उदाहरणों के साथ गीथब विकि को अपडेट करने के लिए @WheatWizard को धन्यवाद ।

• @ ASCII- के लिए धन्यवाद केवल एक ऑनलाइन पूर्णांक मेटागोलर लिखने के लिए जिसने इस कार्यक्रम को लिखने में बहुत मदद की

---

संशोधन

• कुछ धक्का पॉप अतिरेक हटा दिया

• मेरे शून्य काउंटर तर्क को बदल दिया

Comments

Awwwwwweeeeesommmmeeeee!

— अर्जुन

Answer 3

ब्रेन-फ्लैक , 204 196 190 बाइट्स

{({}<>)<>((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())(({<({}<>[({})])>[()]{()(<{}>)}{}<>}{}()<({}<>[({})]){(<{}({}())>)}{}<>>)){(<({}{}<>[{}]{}<>)>)}{}{<>{{}}}{}}<>((){[()]<>})

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

गेहूं के जादूगर को -8 बाइट्स धन्यवाद। -6 राजा को धन्यवाद बाइट्स।

व्याख्या

यह कार्यक्रम दूसरे स्टैक पर सभी वर्तमान अशुद्ध ब्रैकेट के वर्ण कोड संग्रहीत करता है। ब्रैकेट जोड़े <>, []और {}प्रत्येक में वर्ण कोड होते हैं जो बिल्कुल 2 से भिन्न होते हैं, इसलिए उनके लिए विशेष रूप से जांचने की कोई आवश्यकता नहीं है। यह जोड़ी ()केवल 1 से भिन्न होती है, इसलिए हम (विशेष रूप से जांच करते हैं , और प्रभावी रूप से जारी रखने से पहले उस बाइट (वास्तव में हर दूसरे बाइट में वृद्धि) को घटाते हैं।

# While there are bytes left to process
{

 # Move byte to second stack
 ({}<>)<>

 # Push 40, 0, 40, 60, 91, 123: (, then null, then all four opening brackets
 ((((()()()()()){})(({}){})())({}(({})((({}){})(<()>))))())

 ((

   # For each opening bracket type:
   {

    # Evaluate as zero
    <

     # Compute difference between bracket type and input byte
     ({}<>[({})])

    >

    # Evaluate loop iteration as -1 if equal, 0 otherwise
    [()]{()(<{}>)}{}<>

   }

   # Remove the 0 that was inserted to terminate that loop
   {}

   # Add 1 to result
   ()

   # Evaluate rest of this expression as zero
   <

    # Determine whether the byte is open parenthesis
    ({}<>[({})])

    # If not:
    {

     # Add 1 to byte and break if
     (<{}({}())>)

    }{}

    # Return to main stack
    <>

   >

 # Push result twice (0 if matched an opening bracket, 1 otherwise)
 ))

 # If byte was not an opening bracket:
 {

  # Push zero to break out of if
  (<

    # Push (open bracket + 2 - byte) below that zero
    ({}{}<>[{}]{}<>)

  >)

 }{}

 # If byte was neither an opening bracket nor the appropriate closing bracket:
 {

  # Clear alternate stack and stay there to break out of main loop early
  <>{{}}

 }{}

# End of main loop
}

# If a prefix was invalid, the top of the other stack is the same nonzero value
# that made us break out in the first place. If the string was a valid prefix,
# the other stack contains every unclosed bracket.  If the string is balanced,
# there are none of these. Thus, the other stack is empty if the
# brackets are balanced, and has a nonzero value on top otherwise.

# Push 1 on other stack if empty, and 0 on current stack otherwise
<>((){[()]<>})

Comments

"तार्किक नहीं अंतर का" (यह भी जाना जाता है के बराबर होती है) के रूप में के रूप में कम हो सकता है([{}]<>({}))((){[()](<{}>)}{})

— गेहूं जादूगर

मुझे लगता है कि आप उस अंतिम जांच को ({<>[()]}())-6 बाइट्स के साथ बदल सकते हैं

— जो किंग

@JoKing धन्यवाद मुझे नहीं लगता कि मैंने कभी ऐसा देखा होगा।

— नाइट्रोडन

हाँ, मैंने अपने जवाब में इसका पता लगाया और यह महसूस किया कि यह आपके लिए भी लागू है

— जो किंग

Answer 4

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

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

परिणामी मूल के समान होने तक बार-बार ब्रैकेट निकालें, तब तक वापस लौटें जब तक कि स्ट्रिंग अब खाली न हो।

संपादित करें: @ edc65 के लिए 2 बाइट्स सहेजे गए।

Answer 5

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

+`\(\)|\[]|{}|<>

^$

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

Answer 6

CJam, 25 24 23 21 बाइट्स

2 बाइट बचाने के लिए Sp3000 के लिए धन्यवाद।
2 बाइट बचाने के लिए jimmy23013 को धन्यवाद।

q_,{()<>}a`$2/*{/s}/!

परीक्षण सूट।

अनिवार्य रूप से अन्य उत्तर के रूप में ही काम करता है: हम बार-बार हटाने (), [], <>और {}स्ट्रिंग से और अगर हम खाली स्ट्रिंग के साथ अंत की जाँच करें। जब हम कर रहे हैं, तो यह जाँचने से बचने के लिए, हम जोड़े को हटाते हैं Nजहाँ Nस्ट्रिंग की लंबाई होती है, जो हमेशा पर्याप्त होती है (क्योंकि प्रत्येक पुनरावृत्ति कम से कम दो वर्णों को हटा देगा, जब तक कि हम नहीं हो जाते)। मुझे यह देखकर खुशी हुई कि यह रेटिना को हरा नहीं सकता है। :) (हालाँकि पाइथ या जैली हो सकता है ...)

यहाँ एक मजेदार गोल्फ चाल है: स्ट्रिंग को प्राप्त करने के लिए ()<>[]{}हम निम्नलिखित का उपयोग करते हैं:

{()<>}a`$

, {()<>}सिर्फ एक ब्लॉक (यानी एक फ़ंक्शन) है, जिसमें कोड के रूप में अन्य ब्रैकेट शामिल हैं। साथ aहम एक सरणी में ब्लॉक लपेट दें। `Stringifies कि सरणी है, जो देता है "[{()<>}]"। अंत में, हम स्ट्रिंग को क्रमबद्ध करते हैं $, जो कोष्ठक को फिर से व्यवस्थित करता है ()<>[]{}।

Comments

मैं आपकी भाषा से परिचित नहीं हूं, लेकिन आपकी गोल्फ की चाल का वर्णन यह बताता है कि जैसे ()<>[]{}`यह काम करेगा, वैसे ही बाइट्स की संख्या भी सही होगी?

— मूविंग डक

@MooDDuck नहीं क्योंकि ()<>चार ऑपरेटर (वेतन वृद्धि, वेतन वृद्धि, और फिर ऑपरेंड्स के आधार पर तुलना या {}छंटनी ) हैं, जिन्हें तुरंत निष्पादित किया जाएगा, जबकि एक ब्लॉक को दर्शाता है (CJam एक फ़ंक्शन के समतुल्य), यानी कोड का एक टुकड़ा जो बस धकेल दिया जाता है स्टैक पर तुरंत मूल्यांकन के बिना। इसलिए मुझे और {}लपेटने की आवश्यकता है , लेकिन फिर एक सरणी में सब कुछ डालने के लिए उपयोग करने से कम है । ()<>a[...]

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

Answer 7

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

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

एक अभिव्यक्ति बनाता है और जैसा दिखता है वैसा ही बनाता है

s.replace('[]','').replace('()','').replace('{}','').replace('<>','').replace('[]','').replace('()','').replace('{}','').replace('<>','')

और अगर रिजल्ट खाली है तो चेक करें।

Sp3000 ने 8 बाइट्स को इंगित करके बचाया जो कि [],(),{}बिना उद्धरणों के डूबे हो सकते हैं क्योंकि वे पायथन ऑब्जेक्ट्स हैं, और यह कि दो पार्न्स अनावश्यक थे।

Answer 8

याक, 119 बाइट्स

रेगेक्स / प्रतिस्थापित का उपयोग नहीं करता है।

%%input:r;r:%empty|'['r']'r|'{'r'}'r|'('r')'r|'<'r'>'r;%%yylex(){return getchar();}main(){return yyparse();}yyerror(){}

Ungolfed

%%                              # Grammar in BNF
input:
  r;
r:
  %empty
| '['r']'r
| '{'r'}'r
| '('r')'r
| '<'r'>'r;
%%                              # Minimal parser invocation and lexer
yylex(){return getchar();}
main(){return yyparse();}
yyerror(){}

संकलन

yacc -o bracket.c bracket.y
cc -o bracket bracket.c

प्रयोग

~/ % echo -n "<()[]>" | ./bracket
~/ %
~/ % echo -n "{" | ./bracket
~/ 1 %                                                                         :(

Answer 9

पायथ, 31 25 24 बाइट्स

FryAmTheEggMan के लिए 25 बाइट्स के लिए नीचे गिरा 1 बाइट हटा दिया गया

VQ=:Q"<>|\[]|{}|\(\)"k;!

इसे यहाँ आज़माएँ: टेस्ट सूट !

मैं अभी भी एक Pyth नौसिखिया हूँ, किसी भी मदद की सराहना की है।

व्याख्या

VQ                         For N in range(0, len(z)), with Q being the evaluated input.
                           Optimal solution would be to use range(0, len(z)/2) instead, but it add two bytes.
  =:Q"<>|\[]|{}|\(\)"k     assign Q without {}, [], <> nor () (regex replacement) to Q
                      ;    End of For loop
                       !   Logical NOT of Q's length (Q is the input, but has gone several times through y, and Q is implicit).
                           This last operation returns True if len(Q) is 0 (which means all brackets were matched), False otherwise

BTW, अन्य तीर्थ उत्तर के लिए बधाई देता है (जो वर्तमान में 20 बाइट्स है)

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!

— अदनान

@ अदनान शुक्रिया! यह मेरा पहला गोल्फ है!

— फ्लिफी

अच्छा पहला गोल्फ! कुछ पुनर्व्यवस्थित और सामान के साथ, आप 25: तक प्राप्त कर सकते हैं Vz=:z"<>|\[]|{}|\(\)"k;!z। विशेष रूप से ध्यान दें, आपको मूल रूप से उपयोग करने की आवश्यकता नहीं है lयदि आपको वास्तव में नंबर की आवश्यकता नहीं है, और =स्वचालित रूप से एक अभिव्यक्ति में उपयोग किए गए पहले चर का अनुमान लगाता है। मुझे बताएं कि क्या आप मुझे पाइथ चैटरूम में कुछ और समझाना चाहेंगे :)

— FryAmTheEggman

@FryAmTheEggman धन्यवाद! मुझे पता नहीं lथा कि अनावश्यक है, यह जानना अच्छा है। सबसे पहले, मैंने एक फ़ंक्शन घोषित किया क्योंकि मेरा तर्क अलग था, और इसे हटाने के लिए भूल गया। क्या मैं आपका जवाब मेरे लिए शामिल करूंगा? (मैं एक नौसिखिया>। <)

— FliiFe

आमतौर पर, यदि यह एक टिप्पणी में पोस्ट किया गया है, तो टिप्पणी लेखक आपको इसका उपयोग करना चाहता है। तो ठीक है आगे बढ़ो! :)

— FryAmTheEggman 13

Answer 10

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

!uuscNTc"[](){}<>"2G

इसे ऑनलाइन आज़माएं: टेस्ट सूट

बार-बार की घटनाओं को हटा [], (), <>और {}बंटवारे और फिर से विलय से। चेक करता है कि परिणामी स्ट्रिंग खाली है या नहीं।

Answer 11

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

f=_=>_.match(x=/\(\)|\[]|{}|<>/)?f(_.replace(x,'')):!_

कार्यान्वयन की जगह पुनरावर्ती का उपयोग करता है। काफी सरल।

Answer 12

रेगेक्स (पीसीआरई फ्लेवर), 41 37 बाइट्स

^((<(?1)>|{(?1)}|\[(?1)]|\((?1)\))*)$

पुनरावर्ती रेगेक्स के साथ बस एक मानक समाधान।

4 बाइट्स बंद करने के लिए धन्यवाद jimmy23013

Answer 13

पर्ल, 34 33 बाइट्स

के लिए +2 शामिल है -lp

STDIN पर इनपुट के साथ चलाएँ:

./brackets.pl <<< "{<>()}"

brackets.pl:

#!/usr/bin/perl -lp
s/\(\)|\[]|<>|{}//&&redo;$_=!$_

उन दोनों के बीच पहली ब्रैकेट जोड़ी को बिना किसी चीज के ढूंढता है और जब तक कोई भी हो, उसे हटा देता है। फिर जांचता है कि अंतिम स्ट्रिंग खाली है या नहीं।

Comments

s/\(\)|\[]|<>|{}//&&redo;$_=!$_काम नहीं करेगा ? :)

— दादा

यह बहुत अच्छा होगा यदि आप स्पष्टीकरण भी प्रदान कर सकते हैं।

— प्रशांत पोखरियाल

@ दादा का कोर्स। मुझे

— सेनील

Answer 14

ब्रेन-फ्लैक , 204 बाइट्स

(()){{}{({}<>)<>}<>({<(<(({})<>)>)(((((((([(())()()()]){}){}){}())(()))(((())()){}()){})){})(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))<>{}<>{{}({}[({})]<>({})){(<>)(<>)}{}{}(<>)}{}>{}<>}<>)}{}((){<>[()]})

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

नाइट्रोडेन के उत्तर के रूप में काफी छोटा नहीं है , लेकिन बहुत अलग दृष्टिकोण का उपयोग करता है। यह एक बार इनपुट के माध्यम से चलता है, पड़ोसी के मिलान जोड़े को हर बार हटाता है जब तक कि कोई भी न बचा हो। उस बिंदु पर यदि स्टैक पर कुछ भी बचा है, तो स्ट्रिंग पूरी तरह से मेल नहीं खाती थी।

स्पष्टीकरण:

(())  Push 1 to simulate the check at the start of the loop
{  While check
	{}           Pop check
	{({}<>)<>}<> Reverse input
	({           Loop over input
		< Don't push the values of these calculations
		(<(({})<>)>)  Create a copy of the top of the input and push to the other stack
		(((((
		((([(())()()()]){}){}){}())
		(()))
		(((())()){}()){})
		){})          Push the differences in values of the end brackets 
		(({<(({}<>{}[()]))>(){[()](<{}>)}{}<>}{}))  If the copy is the same as any of these, push the difference between the other bracket twice
		<>{}<>  Pop copy
		{  If this character is a start bracket
			{}({}[({})]<>({}))  Check if the next character is the end bracket
			{(<>)(<>)}{}          If not, push a 0 to each stack as buffer
			{}       Pop the top of the input stack, either the start bracket if they matched or the buffer 0
			(<>)     Push 0 to other stack to end check
		}{}>
		{}   Pop the top of the other stack
		         If the character was not an end bracket, pop the copy of check, which is 0
		         If it was, but didn't match the next character, pop the buffer 0
		         If the brackets matched, pop the end bracket and add it to the loop total
	<>}	Repeat with the rest of the input
	<>)	Push the loop total
		If any brackets were matched, the loop total is non zero
}{}
((){<>[()]}) If there is anything left on the stack, push 0 to the other stack, otherwise push 1

Answer 15

ब्रेनफक, 132 बाइट्स

+>,[[<->>+>[-]<<-]<[>+>[<+<+>>>+<-]+++++[>--------<-]>[<<+>++++[>-----<-]>[<++++
+[>------<-]>-[<++++[>--------<-]>[,>]]]]<],]<<[>]>.

प्रारूपित:

+>,
[
  [<-> >+>[-]<<-]
  <
  [
    not matching closing bracket
    >+>[<+<+>> >+<-]
    +++++[>--------<-]
    >
    [
      not open paren
      <<+>
      ++++[>-----<-]>
      [
        not open angle bracket
        <+++++[>------<-]>-
        [
          not open square bracket
          <++++[>--------<-]>
          [
            not open brace
            ,>
          ]
        ]
      ]
    ]
    <
  ]
  ,
]
<<[>]
>.

एक अनुगामी न्यूलाइन के बिना इनपुट की अपेक्षा करता है। \x00झूठे के लिए और \x01सच के लिए प्रिंट ।

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

दृष्टिकोण: \x01जब भी एक उद्घाटन ब्रैकेट का सामना करना पड़ता है, उसके साथ शुरू होने वाले स्टैक को बनाए रखें और एक समान ब्रैकेट को धक्का दें। यह देखने से पहले कि क्या वर्तमान वर्ण एक प्रारंभिक ब्रैकेट है, पहले जांचें कि क्या यह स्टैक के शीर्ष पर क्लोजिंग ब्रैकेट के बराबर है, और यदि यह पॉप है। यदि यह न तो उचित क्लोजिंग ब्रैकेट है और न ही ओपनिंग ब्रैकेट है, तो पॉइंटर को दाईं ओर ले जाते हुए बाकी इनपुट का उपभोग करें। अंत में, जांचें कि सूचक प्रारंभिक के बगल में है या नहीं \x01।

Answer 16

ग्राइम v0.1, 34 बाइट्स

M=\(M\)|\[M\]|\{M\}|\<M\>|MM|_
e`M

1एक मैच के लिए और एक मैच के लिए प्रिंट 0नहीं। इसे ऑनलाइन आज़माएं!

व्याख्या

Grime मेरी 2 डी पैटर्न-मिलान भाषा है जिसे इस चुनौती के लिए डिज़ाइन किया गया है ; यह भी 1D तार मैच के लिए इस्तेमाल किया जा सकता है। इसके साथ यह मेरा पहला जवाब है। मैंने आज Grime को संशोधित किया, लेकिन केवल एक सिंटैक्स तत्व ( `इसके बजाय ,) के चरित्र को बदलने के लिए , इसलिए यह मेरे स्कोर को प्रभावित नहीं करता है।

M=                         Define pattern called M that matches:
\(M\)|\[M\]|\{M\}|\<M\>      a smaller M inside matched brackets,
|MM                          or two smaller Ms concatenated,
|_                           or the empty pattern.
e`M                        Match the entire input against M.

Answer 17

रेंग v.3.3, 137 बाइट्स, नॉनकंपेटिंग

यहाँ यह कोशिश करो!

aií0#zl2,q!~1ø
:"]"eq!v:"}"eq!v:">"eq!v:")"eq!v)1z+#z
ve¤[2-2<       <       <     +1<
>]?v$$$zÀ0#z >ðq!vlqv¤l2%[1Ø
   \$2+)1z+#z/   ~n1/

वहाँ थोड़ा और गोल्फिंग किया जाना है, लेकिन कम से कम यह काम करता है। मैंने ðइस चुनौती के बाद स्टैक का ट्रैक रखने के लिए एक कमांड जोड़ा , ताकि इसे दूरस्थ रूप से संभव / आसानी से किया जा सके। मैं इसे थोड़ा समझाता हूं, लेकिन यह आम तौर पर दोहराए जाने वाले सभी तारों का ट्रैक रखता है और दोहराता है; यदि कोई दोहराव है, तो स्ट्रिंग इरेड्यूसबल है। अन्यथा, स्ट्रिंग खाली स्ट्रिंग / स्टैक में कम हो जाएगी, और आउटपुट करेगी 1। अन्यथा, कोई उत्पादन नहीं किया जाएगा।

Answer 18

PowerShell v2 +, 63 62 बाइट्स

param($a)for(;$a-ne$b){$a=($b=$a)-replace"\[\]|\(\)|<>|{}"}!$a

जावास्क्रिप्ट को काफी नहीं पकड़ सकते हैं, लेकिन वर्तमान में अन्य गैर-esolangs को बाहर कर रहा है।

अन्य उत्तर के रूप में इसी तरह के दृष्टिकोण: एक साधारण पाश है कि इतने लंबे समय हम में से एक को हटा सकते हैं के रूप में जारी [], (), या <>(क्योंकि हम regex विशेष से बचने के लिए की जरूरत है कई बाहरी पात्रों के साथ)। हम $bअपने पिछले लूप के $aरूप में सेट करने के लिए याद रखने के तरीके के साथ एक सहायक के रूप में उपयोग करते हैं । एक अनरिटाइज्ड वैरिएबल है $null, इसलिए पहली बार लूप का सामना करना पड़ता है, $aजाहिर है कि इसके बराबर नहीं है $null।

लूप के अंत में, $aया तो खाली है या नहीं है, और उस स्ट्रिंग का बूलियन- Trueया तो है या नहीं False।

उदाहरण

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({})]"
True

PS C:\Tools\Scripts\golfing> .\are-the-brackets-fully-matched.ps1 "[({])}"
False

Answer 19

सी, 121 122 114 बाइट्स

8 बाइट्स का शेव @xsot करने के लिए धन्यवाद!

a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!k*!i);}

एक स्टैक का उपयोग करता है।

Comments

मुझे पसंद है c%7&2। वास्तव में, आप की जरूरत नहीं है k। इसके बजाय, आप बस वेतन वृद्धि कर सकते हैं iजहां आप संशोधित कर सकते हैं kक्योंकि आपको यह जांचने की आवश्यकता है iकि शून्य वैसे भी है। कुछ इस तरह (अनकहा कोड) a[99],i;main(c){for(;read(0,&c,1);c%7&2?i+=a[i--]^c/9:(a[++i]=c/9))i+=!strchr("()[]{}<>",c);putchar(48+!i);}:।

— xsot

@xsot - क्या मैं काम करूंगा? हमें नकारात्मक मान के साथ सरणी को सब्सक्राइब करने से भी बचने की आवश्यकता है, इसलिए हमें या तो आई या के का परीक्षण करना होगा।

— mIllIbyte

ओह समझा। हालांकि अभी भी सुधार की a[99],i,k;main(c){for(;read(0,&c,!k);c%7&2?k|=a[i--]^c/9:(a[++i]=c/9))k|=!strchr("()[]{}<>",c);putchar(48+!i*!k);}

— गुंजाइश है

@xsot - धन्यवाद! बचत का योग करने के लिए, सहेजे गए 5 बाइट्स पढ़ें, ^ एक को बचाया और सशर्त ऑपरेटर के मध्य ऑपरेटर को बचाया 2. मुझे आश्चर्य है कि सशर्त ऑपरेटर का मध्य संचालन एक असाइनमेंट हो सकता है। मैंने सोचा था कि कोई त्रुटि होगी, जैसे "लापता: पहले ="।

— mIllIbyte

@xsot - मैंने k का उपयोग करने के बजाय मुझे बढ़ाने की कोशिश की, जैसा कि आपने पहले सुझाव दिया था: a[99],i;main(c){for(;read(0,&c,1);c%7&2?i+=a[i]^c/9?1:-1:(a[++i]=c/9))i+=!strchr("()[]{}<>",c);putchar(48+!i);}लेकिन यह इनपुट के लिए अभी तक काम नहीं करता है ())), जैसे कि स्टैक से "पॉपिंग" वास्तव में सरणी में मानों को शून्य नहीं करता है।

— mIllIbyte

Answer 20

जावा 7, 156 151 बाइट्स

class A{public static void main(String[]a){for(int i=0;i<-1>>>1;++i,a[0]=a[0].replaceAll("<>|\\[]|\\(\\)|\\{}",""));System.out.print(a[0].isEmpty());}}

मैं किसी भी पुरस्कार को जीतने की उम्मीद नहीं कर रहा हूं, लेकिन मैंने अभी तक जावा जवाब नहीं देखा है। इसके अतिरिक्त, मैं PPCG के आसपास दुबकना पसंद करता हूं और मुझे अन्य उत्तरों पर वोट / टिप्पणी करने में सक्षम होना पसंद है।

इनपुट को प्रोग्राम पैरामीटर के रूप में दिया गया है। यह उसी प्रारूप का अनुसरण करता है जैसे अन्य कई उत्तर यहां दिए गए हैं कि यह लूप में रेगेक्स रिप्लेसमेंट को बेहतर बनाता है। मूल रूप से मेरे पास यह एन लूप था जहां एन मूल स्ट्रिंग की लंबाई है, लेकिन लूपिंग Integer.MAX_VALUEकम है:]। यह ठीक होना चाहिए क्योंकि जावा में Integer.MAX_VALUEअधिकतम लंबाई है Stringइसलिए एक अंतर्निहित धारणा है कि इनपुट की लंबाई कुछ ऐसी है जो जावा द्वारा संभालती है। रनटाइम काफी खराब है (लूपिटोप पर लगभग 20 मिनट लगते हैं) लूप के कारण, लेकिन मैंने उस पर कोई प्रतिबंध नहीं देखा।

Answer 21

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

infix 1#
'(':x#y=x#')':y
'<':x#y=x#'>':y
'[':x#y=x#']':y
'{':x#y=x#'}':y
')':x#')':y=x#y
'>':x#'>':y=x#y
']':x#']':y=x#y
'}':x#'}':y=x#y
""#""=1
_#_=0

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

Comments

कुछ चीजें: फ़ंक्शन के रूप में (#) को दूसरे तर्क के रूप में खाली स्ट्रिंग के साथ बुलाया जाना चाहिए, इसलिए आपको गणना करने की आवश्यकता है(#"") अपनी बाइट गिनती ओर की । इसके अलावा केवल Trueऔर Falseसत्य / झूठे माने जाते हैं, गाइड टू गोल्फिंग रूल्स ।

— लकोनी

हालाँकि, समापन कोष्ठक के साथ चार पंक्तियों को प्रतिस्थापित किया जा सकता है a:x#b:y|a==b=x#y, बाइट्स को 113 तक नीचे लाया जाता है: इसे ऑनलाइन आज़माएं!

— लकोनी

109 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

Answer 22

पायथन 2.7, 96 बाइट्स

def r(s):i=max(map(s.find,['()','[]','{}','<>']));return not len(s)if i<0 else r(s[:i]+s[i+2:])

Comments

साइट पर आपका स्वागत है!

— DJMcMayhem

Answer 23

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

def m(s,i=0):exec's=s.replace("[({<])}>"[i%4::4],"");i+=1;'*4*len(s);return"">=s

Answer 24

जूलिया, 51 बाइट्स

~z=z==(n=replace(z,r"\(\)|\[]|{}|<>",""))?z=="":~n

कई विकल्पों में से सबसे कम पागल। Unsurprisingly, regex की शक्ति का लाभ स्ट्रिंग मिलान के लिए सबसे छोटा रास्ता है, लेकिन यह वास्तव में केवल तभी लागू होता है जब मैच का पैटर्न नियमित होता है। पीसीआरई पुनरावर्ती पैटर्न को करने की कोशिश कोड के आकार को गुब्बारा करती है, या तो यह देखने के लिए कि क्या पूरी स्ट्रिंग मैच है या सिरों की एंकरिंग कर रही है और फिर रेगेक्स रिकर्सन के लिए आंतरिक निकाय को निर्दिष्ट करने के लिए एक निर्माण का निर्माण करती है। न तो जिनमें से बहुत सुंदर हैं या कोड गोल्फ के लिए अनुकूल हैं।

स्पष्टीकरण:

~z=                            # Define ~z to be the following:
    z==(                       # If z is equal to                                     
        n=replace(z,           # z with the replacement of 
            r"\(\)|\[]|{}|<>", # adjacent matching brackets ((),[],{}, or <>)
            ""                 # with empty strings
        )                      # (which is assigned to n)
    )?z==""                    # whether z is an empty string
    :~n                        # else ~ applied to the substituted string

फ़ंक्शन बार-बार अपने एकमात्र तर्क से कोष्ठक के निकटवर्ती जोड़े को निकालता है, और अगर यह इस तरह से एक खाली स्ट्रिंग प्राप्त कर सकता है तो यह सही है।

Answer 25

sed, 39 36 बाइट्स (कोड के लिए 34, -r के लिए 2)

:a
s/\(\)|\[]|<>|\{}//;ta
/./c0
c1

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

मानक दृष्टिकोण प्रतीत होता है की sed संस्करण। विस्तारित नियमित अभिव्यक्ति की आवश्यकता है (sed -r )

गायों की बोली के लिए 3 बाइट्स सहेजे गए

Comments

आप निकाल सकते हैं aहै :aऔर taबाइट्स को बचाने के लिए

— Kritixi lithos

@KritiiLithos जाहिरा तौर पर GNU sed में एक बग था जिसे 4.3 में हटा दिया गया था । मैं शायद उन पात्रों को छोड़ दूंगा यदि यह प्रविष्टि जीतने के लिए एक नेता के लिए पर्याप्त करीब थी, लेकिन चूंकि यह नहीं है, इसलिए मैं इसे और अधिक पोर्टेबल रूप में छोड़ दूँगा ताकि यह काम करना बंद न करे अधिक सिस्टम के रूप में 4.3 में नवीनीकृत।

— रे

इसे देखते हुए, मुझे यकीन है कि आप वहाँ qसे ड्रॉप कर सकते हैं /./और ब्रेसिज़ भी गिरा सकते हैं। इसे ऑनलाइन आज़माएं! इसकी वजह यह है कि c

— हेंग

@ सहवास धन्यवाद। संपादित।

— रे

Answer 26

05AB1E, 9 बाइट्स

žu2ôõ:g2Q

इनपुट उद्धरणों में दिया गया है।

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

स्पष्टीकरण:

žu          # Push "()<>[]{}"
  2ô        # Split into pieces of size 2
    õ       # Push empty string
            # Implicit input
      :     # Infinite replacement
       g2Q  # Is length equal to 2?
            # Implicit print

Answer 27

क्लोजर, 153 बाइट्स

यहां तक ​​कि सी और ब्रेनफक के जवाबों की तुलना में लंबा: ओ

(defn f[[s & r]](if s(let[[a b](split-at(.indexOf(reductions + 1(for[c r](get(zipmap[s({\(\)\[\]\{\}\<\>}s)][1 -1])c 0)))0)r)](and(not=()a)(f(butlast a))(f b))))1)

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

देखना होगा कि क्या बेहतर तरीका है ...

Answer 28

लूआ , 295 बाइट्स

f = false g = string.gsub t=table s={}b=io.read()for c in b:gmatch('.')do if c:find("[%[<{%(]")then s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")")elseif c:find("[%]>}%)]")then if t.remove(s)~=c then print(f)return end else print(f)return end end if#s>0 then print(f)else print(1)end

Ungolfed संस्करण

f = false
g = string.gsub
t=table
s={} --Define a stack of opening brackets
b=io.read() --get the input
for c in b:gmatch('.') do   --for every character
    if c:find("[%[<{%(]") then
        s[#s + 1] = g(g(g(g(c,"<",">"),"{","}"),"%[","]"),"%(",")") --if the current character is an opening bracket, push the closing bracket onto the stack
    elseif c:find("[%]>}%)]") then
        if t.remove(s)~=c then
            print(f) --if the character is a closing bracket, pop the closing bracket off the stack and test if they match, if not print false
            return
        end
    else 
        print(f) --if the character is not a bracket print false
        return
    end
end
if #s>0 then
    print(f) --if there are still brackets on the stack print false
else
    print(1) --print 1 there are no brackets on the stack
end

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

Answer 29

जाप v2.0a0 -!, 16 बाइट्स

e/\[]|<>|\(\)|{}

कोशिश करो

Answer 30

आर, 298

function(.){s=strsplit;u=paste0;.=s(.,"")[[1]];p=s("><)(}{][","")[[1]];.[!.%in%p]="§";for(i in 1:4*2){.[.==p[i]]=sprintf("S('%s',{",p[i]);.[.==p[i-1]]=sprintf("},'%s');",p[i])};S=function(H,B,T)if(H!=T)stop();r=try(eval(parse(,,u(.,collapse=""))),1);if(inherits(r,"try-error"))FALSE else TRUE}

यहां दृष्टिकोण अनुक्रम को आर कोड में परिवर्तित करना है, और फिर इसे पार्स और मूल्यांकन करने का प्रयास करें। यदि वह त्रुटि देता है, तो वापस लौटें FALSE।

लेकिन एक छोटी सी समस्या है ... ब्रैकेट के लिए आर के नियम अलग हैं, इसलिए <और> कोष्ठक बिल्कुल नहीं हैं, और अन्य प्रकार के अपने स्वयं के नियम हैं। यह एक क्रांतिकारी दृष्टिकोण द्वारा हल किया जाता है - एक चीख़ी कार्य, जिसका एकमात्र कार्य एक त्रुटि को इंगित करना है यदि इसका सिर और पूंछ अलग-अलग तरीकों से चीख़ता है।

उदाहरण के लिए, एस में परिभाषित किया []गया है S('[', {}, ']'), जहां ...

S=function(H,B,T)if(H!=T)stop() 

क्योंकि सिर चीख़ और पूंछ चीख़ मैच, कोई त्रुटि फेंक दिया है।

कुछ अन्य उदाहरण (बायां हिस्सा कोष्ठक का एक क्रम है और दायां भाग वैध आर कोड में इसका परिवर्तन है जिसका मूल्यांकन किया जा सकता है):

[}     -->  S('[', {}, '}')     # squeaks an error
[()]   -->  S('[', {S('(',{},'(')}, "[")
({[]}) -->  S('(',{S('{',{S('[',{},'[');},'{');},'(');

कोष्ठक के कुछ अन्य अनुक्रमों में पार्स त्रुटियों का परिणाम होगा:

[[)    -->   S('[',{S('[',{},'('); 

तो शेष भाग केवल त्रुटियों को पकड़ता है और यदि कोई नहीं है तो FALSE लौटाता है, और यदि कोई नहीं है तो सही है।

मानव-पठनीय कोड:

 sqk <- function(.){
   s=strsplit;u=paste0
   .=s(.,"")[[1]]            # break the argument up into 1-character pieces
   p=s("><)(}{][","")[[1]]   # vector of brackets
   .[!.%in%p]="§"            # replace anything besides brackets by § (--> error)
   for(i in 1:4*2){     
     .[.==p[i]]=sprintf("S('%s',{",p[i])    # '<' -->   S('<',{     ... etc
     .[.==p[i-1]]=sprintf("},'%s');",p[i])  # '>' -->   },'<');     ... etc  
   }
   S=function(H,B,T)if(H!=T)stop()          # define the working horse
   r=try(eval(parse(,,u(.,collapse=""))),1) # evaluate the sequence
   if(inherits(r,"try-error"))FALSE else TRUE   # any errors?
   }

नमूना मामलों पर इसे लागू करना:

truthy<-readLines(textConnection("()
[](){}<>
(((())))
({[<>]})
[{()<>()}[]]
[([]{})<{[()<()>]}()>{}]"))
falsy<-readLines(textConnection("(
}
(<2)>
(()()foobar)
[({}<>)>
(((()))"))
> sapply(truthy,sqk)
                      ()                 [](){}<>                 (((()))) 
                    TRUE                     TRUE                     TRUE 
                ({[<>]})             [{()<>()}[]] [([]{})<{[()<()>]}()>{}] 
                    TRUE                     TRUE                     TRUE 
> sapply(falsy,sqk)
           (            }        (<2)> (()()foobar)     [({}<>)>      (((())) 
       FALSE        FALSE        FALSE        FALSE        FALSE        FALSE