फर्स्ट ब्रैकेट मैच का पता लगाएं

Question

यह ब्रेन-फ्लैक के जन्मदिन तक आने वाली चुनौतियों की एक श्रृंखला थी। यहाँ और अधिक जानकारी प्राप्त करें ।

चुनौती

इस चुनौती के लिए आपका उद्देश्य कोष्ठक के पूरी तरह से मिलान स्ट्रिंग में मिलान करने वाले कोष्ठक की पहली जोड़ी को खोजना होगा ()[]{}<>। पूरी तरह से मेल खाते स्ट्रिंग की डीजेएमकेमायम की परिभाषा उधार लेने के लिए :

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

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

  ()
  []{}
  

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

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

  घनीभूत परतों को भी कई परतों में घोंसला बनाया जा सकता है।

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

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

इनपुट

इनपुट में केवल अक्षरों के साथ एक एकल नॉनमोटिव स्ट्रिंग या चार सरणी होगी ()[]{}<>, और पूरी तरह से मिलान होने की गारंटी है। आप किसी भी उचित तरीके से इनपुट ले सकते हैं जो हमारे i / o चूक के साथ मेल खाता है ।

उत्पादन

आपके प्रोग्राम या फ़ंक्शन का आउटपुट ब्रैकेट का सूचकांक होगा जो पहले एक को बंद करता है। आउटपुट या तो अनुक्रमित होना चाहिए । फिर से, आउटपुट किसी भी उचित तरीके से हो सकता है जो हमारे i / o चूक के साथ मेल खाता है ।01

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

Input       0-indexed   1-indexed
()          1           2
(<>)        3           4
<[]{<>}>    7           8
{}{}{}{}    1           2
[[]<>[]]    7           8

यह कोड-गोल्फ , सबसे कम बाइट्स जीतता है!

Comments

बोनस अंक अगर आप ब्रेन-फ्लैक

— ofc

@EriktheOutgolfer हो गया

— DJMcMayhem

यह तकनीक BF के अक्षम कार्यान्वयन को लिखने के लिए बहुत सहायक है।

— 2

Answer 1

वी , 4 बाइट्स

%Dø.

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

यह, अधिकांश V उत्तरों के विपरीत, 0-इंडेक्सिंग का उपयोग करता है। मुझे इस जवाब पर बहुत गर्व है, और मेरी भाषा कितनी दूर आ गई है। स्पष्टीकरण:

%       " Jump to the first bracket match
 D      " Delete everything under and after the cursor
  ø     " Count the number of times the following regex is matched:
   .    "   Any character

Comments

क्या आपके पास मिलान के लिए बॉयलरप्लेट की आवश्यकता नहीं है <>?

— पावेल

@ पावेल इन विम, यस। लेकिन वी में नहीं

— DJMcMayhem

Answer 2

ब्रेन-फ्लैक , 685, 155, 151 , 137 बाइट्स

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

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

कोड के 136 बाइट्स, प्लस एक बाइट के लिए -a। एक अनुक्रमित।

530 बाइट्स बंद गोल्फ! शायद यह सबसे बड़ा गोल्फ है जो मैंने कभी किया है।

14 बाइट्स ने बचाया रिले को धन्यवाद!

यह उद्घाटन / समापन कोष्ठक के एक फार्मूले का दुरुपयोग करता है: यदि आप ASCII मान लेते हैं, तो इसे एक से बढ़ाएँ, और 4 का मोडुलो लें, ओपनर्स ( ({[<) हमेशा मिलेगा 0या 1, जबकि क्लोजर ( )}]>) हमेशा 2 या 3 होगा।

स्पष्टीकरण:

#Push 1
(())

#While true
({<

    #Pop stack height
    {}

    #Compute (TOS + 1) % 4
    ({}()<(()()()())>)({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

    #Decrement if positive
    (({})){{}({}[()])(<()>)}{}

    #Push 0 onto alternate
    (<>)

    #Toggle back
    <>

    #Pop two zeros from alternate if closer
    {{}<>{}({}<>)}{}

    #Push height of alternate stack
    (<>[]<>)

#Make each time through evaluate to 1
>()

#Endwhile
}

#Push the number of loops onto the offstack
<>)

Comments

भगवान के प्यार के लिए, पृथ्वी पर यह क्या है।

— लीकी नून

मूल रूप से हर कोई अब उपयोग कर रहा है n-1&2/ n+1&2/ -n&2या n%7&2खुलने और बंद होने वाले कोष्ठकों को

— भेदने के लिए

@ETHproductions मुझे यकीन नहीं है कि अगर ब्रेन-फ्लैक कुशलता से गणना कर सकता है &2, लेकिन मैं इसे देखूंगा ।

— DJMcMayhem

ओह, मुझे लगा कि तुम थे। आप 0/ 1और 2/ के बीच अंतर करने के लिए कुछ ऐसा ही कर रहे होंगे, 3हालांकि अब जब मैं इसे देखता हूं, तो आप सकारात्मक होने पर ही इसे घटा रहे हैं। एक अच्छी चाल के रूप में अच्छी तरह से :-)

— ETHproductions

(TOS+1)%4कम हो सकते हैं: यह ऑनलाइन कोशिश करो!

— मेगाटॉम

Answer 3

05AB1E , 17 16 10 बाइट्स

-1 carusocomputing के लिए धन्यवाद

-6 अदनान को उनकी अद्भुत अंतर्दृष्टि के लिए धन्यवाद कि "वेतन वृद्धि के बाद, दूसरा अंतिम बिट एक उद्घाटन ब्रैकेट के लिए 0 और समापन ब्रैकेट के लिए 1 है"

Ç>2&<.pO0k

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

Ç          # Get input as ASCII values
 >         # Increment
  2&       # And with 2 (0 for open and 2 for close brackets)
    <      # decrement 
     .p    # prefixes
       O   # Sum
        0k # Print the index of the first 0

Comments

žuयहाँ प्रयोग करने योग्य लगता है।

— मैजिक ऑक्टोपस Urn

žu8ÝÈÏहां, नहीं, वास्तव में योग्य नहीं। सबसे अच्छा यह अभी भी 5 बाइट्स होगा। मैं ब्रेसिज़ के जोड़े में विभाजित होने के बारे में सोच रहा था, और ब्रेसिज़ को तब तक हटाता हूं जब तक कि केवल एक जोड़ी नहीं बची हो, प्रत्येक हटाए गए जोड़े के लिए वेतन वृद्धि काउंटर 2। मुझे कोई पता नहीं अगर यह कम है। इसे बाहर की कोशिश कर रहा है।

— मैजिक ऑक्टोपस Urn

10 बाइट्स के लिए Ç>2&<.pO0k:।

— अदनान

बस ASCII मूल्यों के साथ खिलवाड़ । ध्यान दें कि वेतन वृद्धि के बाद, दूसरा अंतिम बिट 0एक खोलने वाले ब्रैकेट के लिए और 1समापन ब्रैकेट के लिए है।

— अदनान

Answer 4

विम, 23 बाइट्स

:se mps+=<:>
%DVr<C-a>C1<esc>@"

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

मैं इस जवाब से वाकई दुखी हूं। यह समाधान खूबसूरती से सुरुचिपूर्ण और छोटा है, लेकिन, डिफ़ॉल्ट रूप से, विम पर विचार नहीं किया जाता है <और >मिलान किया जाना है, इसलिए मुझे बॉयलरप्लेट कोड के 13 बाइट्स की आवश्यकता है। अन्यथा, यह सिर्फ 10 बाइट्स होगा।

मैंने एक वी उत्तर पोस्ट किया होगा, लेकिन वह केवल एक बाइट से छोटा होगा, अर्थात् में बदल Vrजाएगा Ò, क्योंकि Vrयह एक आम विम-मुहावरा है।

यह 1-अनुक्रमित है, लेकिन trivially संशोधित किया जा सकता है 0-अनुक्रमित से बदलकर 1a 0।

:se mps+=<:>        " Stupid boilerplate that tells vim to consider `<` and `>` matched
%                   " Jump to the bracket that matches the bracket under the cursor
 D                  " Delete everything from here to the end of the line
  V                 " Visually select this whole line
   r<C-a>           " Replace each character in this selection with `<C-a>`
                    " This conveniently places the cursor on the first char also
         C          " Delete this whole line into register '"', and enter insert mode
          1<esc>    " Enter a '1' and escape to normal mode
                @"  " Run the text in register '"' as if typed. Since the `<C-a>` command
                    " Will increment the number currently under the cursor

Comments

V उत्तर दें फिर :)

— आउटगोल्फर

Answer 5

जेली , 11 10 9 बाइट्स

O’&2’+\i0

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

व्याख्या

यहां विचार "जादू सूत्र" खोजने का था जो समापन कोष्ठक से खुलने को अलग कर सकता है। मैंने मूल रूप से इस्तेमाल किया O%7&2(यानी "एएससीआईआई कोड, मोडुलो 7, बिटवाइज़-एंड 2") ले लो, लेकिन @ETHproductions ने सुझाव दिया O’&2(जो मॉडुलो 7 को एक वेतन वृद्धि के साथ बदल देता है); दोनों एक प्रकार के ब्रैकेट के लिए 0 और दूसरे के लिए 2 लौटाते हैं। 1 ( ’) को घटाकर ये परिणाम -1 और 1 बना देगा।

बाकी कोड है +\। +\एक संचयी राशि पैदा करता है। यदि कोष्ठक का एक सेट सही ढंग से मेल खाता है, तो इसमें -1 और 1 की संख्या समान होगी, अर्थात इसका संचयी योग 0. होगा। तब हमें परिणामी सूची में पहले 0 के सूचकांक को वापस करना होगा; हम ऐसा कर सकते हैं i0।

Comments

समापन कोष्ठक का पता लगाने के लिए हमने एक समान दृष्टिकोण लिया। दुर्भाग्य से मुझे केवल एक अवर संस्करण मिला:b*2%7>3

— 2501

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

— हाइपरएन्यूट्रीनो

Answer 6

रेटिना , 26 24 बाइट्स

M!`^.(?<-1>([[({<])*.)*

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

परिणाम 1-आधारित है।

व्याख्या

एक बहुत ही अलग रेटिना समाधान जो अनिवार्य रूप से एकल (और बहुत पठनीय ...) रेगेक्स पर आधारित है। यह एक नई तकनीक का उपयोग करता है जिसे मैंने कल संतुलित समूहों का उपयोग करके संतुलित तारों के मिलान के लिए खोजा था ।

M!`^.(?<-1>([[({<])*.)*

खोजें ( M) और वापसी ( !) रेगेक्स के सभी मैच ^.(?<-1>([[({<])*.)*। रेगेक्स स्ट्रिंग के पहले चरित्र को छोड़ देता है और फिर नेस्टिंग की गहराई पर नज़र रखने के लिए बैलेंसिंग समूहों का उपयोग करता है। किसी भी [({<गहराई में वृद्धि (समूह द्वारा ट्रैक रखी गई 1) और किसी भी अन्य चरित्र की गहराई कम हो जाती है (सिद्धांत .रूप में, साथ ही साथ कोष्ठक खोलने से गहराई को कम करने की अनुमति मिलती है, लेकिन चूंकि रेगेक्स का लालच से मिलान किया जाता है, इसलिए बैकट्रैक कभी भी प्रयास नहीं करेगा। )। अजीब चाल यह है कि (?<-1>...)संलग्न समूह 1जो काम करता है क्योंकि संतुलन समूह से पॉपिंग समूह के अंत में होता है । यह फॉर्म में मानक दृष्टिकोण पर दो बाइट्स बचाता है((open)|(?<-2>close))*। आवश्यक रूप से मैच ब्रैकेट पर रुक जाता है जो पहले वाले को बंद कर देता है, क्योंकि हमने इसे छोड़ दिया था, इसलिए इसका स्टैक गहराई में हिसाब नहीं है (और स्टैक की गहराई नकारात्मक नहीं जा सकती)।

इस मैच की लंबाई उस ब्रैकेट का 0-आधारित सूचकांक है जिसकी हम तलाश कर रहे हैं।

बस इस स्ट्रिंग में खाली मैचों की संख्या की गणना करें। खाली रेगेक्स हमेशा एक से अधिक बार मेल खाता है क्योंकि स्ट्रिंग में वर्ण हैं, इसलिए यह हमें उस ब्रैकेट का 1-आधारित इंडेक्स देता है जिसकी हम तलाश करते हैं।

Comments

ये तो बहुत खूब है!

— पावेल

छोटा दृष्टिकोण : पहले भाग से मिलान करने के बजाय स्ट्रिंग के दूसरे भाग को हटा दें। मुझे पसंद है कि आपने स्ट्रिंग की लंबाई कैसे मापी, btw!

— सिंह

@ लियो वास्तव में साफ है! आप इसे एक अलग उत्तर के रूप में पोस्ट कर सकते हैं :)

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

ठीक है, संतुलित तारों के लिए यह नई चाल अद्भुत है: डी

— लियो

Answer 7

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

.(([[({<])|(?<-2>.))*$

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

यह मार्टिन एंडर के समाधान से प्रेरित है ।

व्याख्या

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

निम्न पंक्ति खाली है, इसलिए हम एक खाली स्ट्रिंग के साथ मैच को बदलते हैं, जिसका अर्थ है कि हमें अब (0-अनुक्रमित) वांछित परिणाम प्राप्त करने के लिए शेष वर्णों को गिनने की आवश्यकता है।

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

Comments

मुझे कल संतुलित तारों के मिलान के लिए एक नई तकनीक मिली, जो हमारे दोनों उत्तरों पर दो बाइट्स बचाती है: tio.run/##K0otycxL/K@q4Z7wX0/D3kbX0E4jOjjqj2iZWU0tPU0u@@/ (और शायद एक दर्जन अन्य) जो मैंने लिखे हैं। अतीत ...)

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

Answer 8

पर्ल 5 , 28 बाइट्स

मार्टिन एंडर से सिर्फ के .बजाय का उपयोग करके 6 बाइट्स [>})\]]बचाता है रेटिना जवाब ।

कोड + -pध्वज के 27 बाइट्स ।

/([<{([](?0)*.)+?/;$_=$+[0]

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

पुनरावर्ती रेक्स, एक सुंदर आविष्कार।
रेगेक्स एक ओपनिंग ब्रैकेट ( [<{([]) के लिए दिखता है , उसके बाद रिक्सेसिव कॉल ( ?0), इसके बाद क्लोजिंग ब्रैकेट ( .) होता है। यह सब गैर-लालची ( +?) है इसलिए यह शुरुआत से जितना संभव हो उतना कम मेल खाता है। मैच के अंत का सूचकांक उत्तर है, और जैसा कि होता है, इसमें पाया जा सकता है $+[0]।

Answer 9

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

@ अदनान को 1 बाइट धन्यवाद दिया

f=([c,...s],i=1)=>(i-=-c.charCodeAt()&2)&&1+f(s,++i)

प्रत्येक ओपनिंग ब्रैकेट के लिए, इसके चार-कोड मॉड 4 लेने से हमें 0 या 3 मिलता है; समापन कोष्ठक के लिए, यह हमें 1 या 2 देता है। इसलिए, हम ब्रैकेट के चार-कोड (जो बिट्स को हटाते हैं और 1 घटाते हैं) को नकारकर और दूसरे कम से कम महत्वपूर्ण बिट को खोलकर और बंद करने के बीच अंतर कर सकते हैं; वह यह है कि n&2।

Comments

मुझे लगता है कि इसके बजाय n-1&2, -n&2यह भी काम करता है?

— अदनान

@ अदनान हम्म, मुझे लगता है कि आप सही हैं। धन्यवाद!

— ETHproductions

Answer 10

सी, 75 72 56 55 54 54 बाइट्स

a;f(char*s){return(a-=(-*s++&2)-1)?1+f(s):0;}

इसे देखें ऑनलाइन ।

यदि आप चाहते हैं कि आउटपुट 0-अनुक्रमित के बजाय 1-अनुक्रमित हो, तो अंतिम 0को प्रतिस्थापित करें 1।

Answer 11

पायथन 2.7 + Numpy, 85 79 बाइट्स

कोड गोल्फ में मेरा पहला प्रयास:

from numpy import*
lambda s:list(cumsum([(ord(x)+1&2)-1for x in s])).index(0)

Comments

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

— DJMcMayhem

आपको लैम्ब्डा का नाम नहीं लेना है, आप

— Pavel

Answer 12

ब्रेन-फ्लैक , 97 बाइट्स (कोड के लिए 96, ध्वज के लिए 1)

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

-aझंडे के साथ भागो ।

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

स्पष्टीकरण:

#Skip the first open bracket 
{}

#Place a 1 on stack B, representing the nesting depth
<>(())

#Start a loop, until the depth is 0
({<

 #Divide the ASCII code by 2, rounding up
 (<()>)<>({<({}[()])><>([{}]())<>}{})<>

 #Replace TOS B with a 1
 (<{}>())

 #Swap back to stack A
 <>

 #Negate the 1 on stack B n times (n = ASCII value+1/2)
 {({}[()])<>([{}])<>}{}

 #Swap back to stack B
 <>

 #Add the 1/-1 (depending on Open/close bracket) to the nesting depth accumulator
 ({}{})

 #Count loop cycles
 >()

#end loop, print result implicitly by pushing to the stack 
}{}) 

यह सिर्फ काम करता है, ठीक है।

Answer 13

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

^.
!
T`([{}])`<<<>
+T`p`!`<!*>
\G!

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

परिणाम 0-आधारित है।

व्याख्या

^.
!

पहले अक्षर को a से बदलें !। यह उस ब्रैकेट का कारण बनता है जिसे हम बेमिसाल होना चाहते हैं।

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

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

+T`p`!`<!*>

बार-बार ( +) एस के <!*>साथ सभी मैचों में प्रत्येक चरित्र को बदलें !। यही है, हम उन कोष्ठकों के युग्मों से मेल खाते हैं, जिनमें आगे कोई भी असंसाधित कोष्ठक नहीं है और उन्हें आगे के विस्मयादिबोधक चिह्न में बदल देते हैं। यह बेजोड़ समापन कोष्ठक को छोड़कर पूरे स्ट्रिंग को बदल देगा।

\G!

अग्रणी विस्मयादिबोधक चिह्नों की संख्या की गणना करें, जो कि पहले गैर-विस्मयादिबोधक चिह्न (यानी बेजोड़ ब्रैकेट) की 0-आधारित स्थिति के बराबर है। \Gएंकर पिछले एक है, जिसके कारण यह नहीं गिना जाता करने के लिए प्रत्येक मैच !कहा ब्रैकेट के बाद एस।

Comments

मैंने देखा कि आपने होम पेज पर उत्तर दिया था और जानते थे कि यह किसी प्रकार का रेक्सक्स इस्तेमाल करने जा रहा है

— क्रिस्टोफर

@ क्रिस्टोफर एह, यह मुश्किल से किसी भी regex का उपयोग करता है (जैसा कि मैंने अभी पोस्ट किया अन्य रेटिना जवाब के विपरीत)।

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

शीश। रेगेक्स ज्यादा?

— क्रिस्टोफर

यह काम क्यों नहीं कर रहा है?

— लीक

@LeakyNun क्योंकि (?!(2))सिर्फ है (?!2)। आप शायद मतलब (?(2)(?!))या (?2)!)। आप भी बच निकलना भूल गए ]और अंतिम +होना चाहिए *।

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

Answer 14

PHP, 116 बाइट्स

for($l=["("=>")","["=>"]","{"=>"}","<"=>">"][$f=$argn[0]];;$d>0?$i++:die("$i"))$d+=$f!=($n=$argn[$i])?$n==$l?-1:0:1;

ऑनलाइन संस्करण

Comments

क्या PHP को शुरू करने की आवश्यकता नहीं है <?php?

— पावेल

@Phoenix: एक स्टैंडअलोन PHP दुभाषिया है जिसे शुरुआती टैग की आवश्यकता नहीं है। यह आमतौर पर गोल्फ के लिए उपयोग किया जाता है।

@ ais523 इस मामले में PHP कमांड लाइन से -R विकल्प के साथ चलती है

— Jörg Hülsermann

Answer 15

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

f=lambda s,r=[],i=0:(i<1or sum(r))and f(s[1:],r+[(ord(s[0])+1&2)-1],i+1)or i

पुनरावर्ती फ़ंक्शन जो अदनान (और संभवतः अन्य) द्वारा पाए गए कई बनाम द्वारा उपयोग किए जाने वाले खुले बनाम नज़दीकी चाल के लिए एक ध्वज के रूप में क्रमिक 2 एलएसबी का उपयोग करता है। टेल हिट तब होती है जब -1ओपन के लिए और 1करीब के लिए संचयी योग शून्य तक पहुँच जाता है। इंडेक्स को चर में रखा जाता है क्योंकि यह बाइट से सस्ता है len(r), इंडेक्सिंग 1-आधारित है।

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

Answer 16

रूबी, 35 34 बाइट्स

p$_[/[<{(\[](\g<0>)*[>})\]]/].size

दादा के पर्ल 5 जवाब के आधार पर । आउटपुट 1-अनुक्रमित है। रूबी दुभाषिया की आवश्यकता होती है -nविकल्प के साथ लागू (निहित)while gets लूप) के ।

संपादित करें: यह भी 35 34 बाइट्स है, लेकिन इस उत्तर को और कम करने के लिए एक और संभावित शुरुआती बिंदु है।

p$_[/[<{(\[](\g<0>)*[>})\]]/]=~/$/

Edit2: के बाद अनावश्यक स्थानों को हटा दिया p।

Edit3: कुछ और 34-बाइट उत्तर।

~/[<{(\[](\g<0>)*[>})\]]/;p$&.size
p~/[<{(\[](\g<0>)*[>})\]]/+$&.size

Comments

PPCG में आपका स्वागत है!

— पावेल

बहुत सराहना की! :)

— रे हैमेल

Answer 17

पायथन 3 , 59 55 50 49 बाइट्स

f=lambda s,n=1:n and-~f(s[1:],n+1-(-ord(s[1])&2))

आउटपुट 0-अनुक्रमित है। ब्रैकेट दिशा निर्धारित करने का सूत्र पहली बार @ETHProductions द्वारा खोजा गया था और @ Adnan द्वारा सुधार किया गया था।

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

Answer 18

बैच, 172 बाइट्स

@set/ps=
@set/ai=d=0
:l
@set/ai+=1,d-=1
@set c="%s:~,1%"
@set "s=%s:~1%
@for %%a in ("<" "(" "[" "{")do @if %%a==%c% set/ad+=2&goto l
@if %d% gtr 0 goto l
@echo %i%

1 अनुक्रमित। <>एस निश्चित रूप से बैच में विशेष पात्र हैं, इसलिए न केवल मुझे सभी को उद्धृत करना होगा, बल्कि मैं उन्हें gotoलेबल बनाने जैसे गुर भी नहीं कर सकता ।

Answer 19

आर, 126 बाइट्स

s=readline();i=0;r=0;for(c in strsplit(s,"")[[1]]){if(grepl("[\\[\\(\\{<]",c))i=i+1 else i=i-1;if(i==0){print(r);break};r=r+1}

Answer 20

सी, 127 बाइट्स

ऑनलाइन प्रयास करें

c(x){x-40&x-60&x-91&x-123?-1:1;}
f(i,t)char*t;{return i?f(i+c(*t),t+1):t;}
s(char*t){return f(c(*t),t+1)-t;}

उत्पादन

2   ()
4   (<>)
8   <[]{<>}>
2   {}{}{}{}
8   [[]<>[]]

Comments

कोई टिप्पणी, downvoter।

— खलद.क।

मैं नीच नहीं था, लेकिन मुझे नहीं लगता कि इससे मदद मिलती है कि पहले से ही बहुत कम सी सबमिशन था।

— अर्जन जोहान्सन