17

अभी तक एक और Brainfuck पार्सिंग समस्या है, लेकिन इस बार ... अलग।

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

चूंकि ट्यूरिंग मशीन (विशेष रूप से तेज़ वाले) महंगी हैं (आखिरकार, उनके पास अनंत रैम है जो लागत है), यह सुनिश्चित करना बेहतर होगा कि कोड को निष्पादित करने से पहले प्रोग्राम में कोई सिंटैक्स त्रुटियां नहीं हैं। आपकी कंपनी बहुत सारे कोड चलाने जा रही है, इसलिए मैन्युअल सत्यापन काम नहीं करेगा। एक प्रोग्राम लिखें, जो ब्रेनफक कोड के लिए STDIN को पढ़ता है, और 0 (त्रुटि) के अलावा किसी भी चीज़ से बाहर निकलने की स्थिति के साथ बाहर निकलता है यदि प्रोग्राम में कोई सिंटैक्स त्रुटि है (उदाहरण के लिए, ]एक सिंटैक्स त्रुटि है, क्योंकि कोई मेल नहीं है [)। यदि प्रोग्राम पूरी तरह से ठीक है, तो एग्जिट स्टेटस से 0 पर सेट करें।

सुनिश्चित करें कि आपके प्रोग्राम में गलतियाँ शामिल हैं []। आप एक और कंप्यूटर को विस्फोट नहीं करना चाहेंगे, क्या आप करेंगे? ओह, और सुनिश्चित करें कि यह जितना संभव हो उतना छोटा है - आपका बॉस छोटे कार्यक्रमों के लिए भुगतान करता है (क्योंकि वह सोचता है कि वे तेज हैं, या कुछ और)। ओह, और आपको Brainfuck में कोड करने की आवश्यकता नहीं है (वास्तव में, आप नहीं कर सकते, क्योंकि Brainfuck निकास कोड का समर्थन नहीं करता है) - आपका कोड सामान्य कंप्यूटर पर चलाया जाएगा।

इसलिए, जैसा कि आप देख सकते हैं, आपका काम यह जांचना है कि क्या ब्रेनफक प्रोग्राम "वैध" है (जोड़े गए []प्रतीकों का)। कृपया ध्यान दें कि Brainfuck प्रोग्राम में अन्य वर्ण हो सकते हैं [], इसलिए प्रोग्राम को केवल इसलिए मना न करें क्योंकि इसमें अन्य कमांड हैं। सबसे छोटा कोड जीतता है, लेकिन शायद आप किसी भी तरह से upvotes के बारे में अधिक परवाह करेंगे।

— कोनराड बोरोस्की
स्रोत

1

उन भाषाओं के बारे में जो एक प्रक्रिया से बाहर निकलने के कोड को स्थापित करने की अनुमति नहीं देते हैं?

— केंडल फ्रे

1

@ केंडलफ्रे: सिंपल, कुछ और उपयोग करें। या गोल्फस्क्रिप्ट में, रूबी कोड एम्बेड करें। शायद यह कुछ गूढ़ प्रोग्रामिंग भाषाओं को अवरुद्ध करता है, लेकिन अच्छी तरह से ...

— कोनराड बोरोस्की

1

क्या असफलता पर 1 के अलावा कुछ के लिए त्रुटि कोड सेट करना ठीक है (जब तक कि यह निश्चित रूप से 0 नहीं है)?

— मारिनस

@marinus: मुझे नहीं पता कि आप ऐसा क्यों चाहते हैं, लेकिन मुझे लगता है कि यह ठीक है।

— कोनराड बोरोस्की

@GlitchMr: क्योंकि तब मैं GCD(a,b)इसके बजाय उपयोग कर सकता हूं 0 != a || b।

— मारिनस

6

GolfScript, 18 वर्ण

.{[]`?)},~](`91?./

यह कोड एक्ज़िट कोड 0 के साथ सफलतापूर्वक चलता है (और कुछ कूड़े को stdout में प्रिंट करता है) यदि इनपुट में वर्ग कोष्ठक संतुलित हैं। यदि वे नहीं हैं, तो यह एक गैर-शून्य निकास कोड के साथ विफल हो जाता है और stderr के लिए एक त्रुटि संदेश प्रिंट करता है, जैसे:

(eval):2:in `/': divided by 0 (ZeroDivisionError)

या

(eval):1:in `initialize': undefined method `ginspect' for nil:NilClass (NoMethodError)

चूंकि चुनौती ने stdout / stderr को आउटपुट के बारे में कुछ नहीं कहा, इसलिए मुझे यह योग्यता है। किसी भी मामले में, आप हमेशा उन लोगों को पुनर्निर्देशित कर सकते हैं /dev/null।

स्पष्टीकरण:

कोड {[]`?)},सब कुछ स्ट्रिप्स करता है, लेकिन इनपुट से वर्ग कोष्ठक, और ~परिणाम को गोल्फस्क्रिप्ट कोड के रूप में मूल्यांकन करता है। मुश्किल हिस्सा यह है कि असंतुलित कोष्ठक GolfScript (और, वास्तव में, मेरे कोड में एक शामिल है!) में पूरी तरह से कानूनी हैं, इसलिए हमें कोड क्रैश करने के लिए किसी अन्य तरीके की आवश्यकता है।

मैं जिस ट्रिक का उपयोग कर रहा हूं वह स्टैक के नीचे इनपुट की एक कॉपी छोड़ना है, पूरे स्टैक को एक सरणी में इकट्ठा करें (एकीकृत का उपयोग करके) ] ) और पहले तत्व को बंद करें। इस बिंदु पर, तीन चीजें हो सकती हैं:

यदि इनपुट एक समाप्त हो गया है [ , तो खाली सरणी से एक तत्व को स्थानांतरित करने की कोशिश करने से दुभाषिया दुर्घटनाग्रस्त हो जाएगा (जो, इस मामले में, वास्तव में हम क्या चाहते हैं!)
यदि इनपुट में कोष्ठक संतुलित थे, तो स्थानांतरित तत्व मूल इनपुट स्ट्रिंग होगा।
अन्यथा (यदि इनपुट में एक बंद ]या अशुद्ध था [) तो यह एक सरणी होगी।

मेरी मूल 14-चर प्रविष्टि ने एक स्ट्रिंग के साथ स्थानांतरित मूल्य की तुलना की, जो कि एक नेस्टेड सरणी होने पर दुर्घटनाग्रस्त हो जाएगी। दुर्भाग्य से, यह पता चला है कि एक स्ट्रिंग के साथ एक फ्लैट (या, विशेष रूप से, खाली) सरणी की तुलना भी गोल्फस्क्रिप्ट में कानूनी है, इसलिए मुझे शुल्क स्विच करना पड़ा।

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

Ps। दो अन्य 18-चार समाधान हैं:

.{[]`?)},{.}%~](n<

तथा

.{[]`?)},~]([n]+n<

काश, मुझे अभी तक "खाली सरणी समस्या" को हल करने का एक छोटा तरीका नहीं मिला है।

— इल्मरी करोनें
स्रोत

क्या यह संतुलित है ?: ][(यानी यह आपके कार्यक्रम में विफल रहता है?)

— जस्टिन

@Quincunx: यह विफल रहता है, जैसा कि यह होना चाहिए।

— इल्मरी करोनें

हालांकि, यह स्वीकार करने के लिए निकला [[]; मैंने इसे अभी तय किया है, 4 वर्णों की कीमत पर, और यह अब मेरे सभी परीक्षणों को पास करता है।

— इल्मरी करोनें

अगर मैं आपको सही तरीके से समझूं, तो आपके पास एक 14-चार समाधान था जो केवल एक स्ट्रिंग और एक सरणी के बीच अंतर करने में विफल रहता है, जबकि सरणी खाली है। 1+एक खाली सरणी को एक गैर-खाली सरणी, एक गैर-खाली सरणी को एक गैर-खाली सरणी और एक स्ट्रिंग में एक स्ट्रिंग में बदल देगा।

— पीटर टेलर

@PeterTaylor: हाँ, यह था .{[]`?)},~](n<। मैं अपने प्रयास किया 1+है, लेकिन यह है कि सरणी की जरूरत है कुछ को रोकने के लिए लगता है अन्य एक नंबर से (शायद इसलिए है कि दुभाषिया जब यह रिकर्सिवली एक सरणी / तार के साथ एक चरित्र की तुलना करने की कोशिश करता है दुर्घटना होगा)। का उपयोग करना n+या तो काम नहीं करता है, क्योंकि यह सरणी को एक स्ट्रिंग के लिए मजबूर करता है; काम [n]+ करता है , लेकिन अभी भी मुझे 18 वर्णों पर रखता है।

— इल्मरी करोनें

17

ब्रेनफक 76 बाइट्स

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

यदि स्क्वायर ब्रैकेट्स असंतुलित होकर bf दुभाषिया / कंपाइलर को रनटाइम में विफल कर रहे हैं तो उनमें से यह बॉन्ड से बाहर चला जाता है और उनमें से कुछ में यह प्रतिबिंबित करने के लिए निकास कोड होते हैं।

eof = 0, रैपिंग वैल्यू और कोशिकाओं की परिमित संख्या की आवश्यकता होती है

उबंटू में आप दुभाषिया का उपयोग कर सकते हैं bf( sudo apt-get install bf)

% echo '[[[]' | bf -n bf_matching.bf
Error: Out of range! Youwanted to '<' below the first cell.
To solve, add some '>'s at the beginning, for example.
an error occured
% echo $? 
5
% bf -n bf_matching.bf < bf_matching.bf
% echo $?
0

— Sylwester
स्रोत

5

मुझे पसंद है कि आपने ब्रेनफक का उपयोग कैसे किया भले ही प्रश्न ने कहा कि असंभव था।

— 1

ओह वाह। मैं ईमानदारी से हैरान हूं। मैंने माना कि यह असंभव था, लेकिन ऐसा नहीं है।

— कोनराड बोरोस्की

1

@ एक्सिक्स: ब्रेनफुक ट्यूरिंग-पूर्ण है इसलिए यह कुछ भी कर सकता है (I / O बाधाओं को देखते हुए।)

— marinus

2

@marinus ट्यूरिंग पूर्णता का मतलब केवल यह है कि यह सभी गणना कर सकता है। BrainfuckI / O के बिना ट्यूरिंग पूर्ण है क्योंकि आप एक प्रोग्राम चला सकते हैं जो किसी भी गणना की गणना करता है और चलाने के बाद इसकी मेमोरी का निरीक्षण करके परिणाम देखता है। बिना आई / ओ के बीएफ लोगों को कम दिलचस्पी देगा क्योंकि उपयोगिताओं को बनाना मुश्किल होगा। उदाहरण के लिए मैं अपने लिस्प दुभाषिया कभी नहीं बना सकता ।

— सिल्वेस्टर

14

Befunge 98 - 26 31 20 19 वर्ण

~:']-!\'[-!-+:0`j#q

कुछ विशाल दशाओं से छुटकारा मिला। अब कार्यक्रम निम्नानुसार काम करता है:

~:   read an input char and duplicate it

']-! push a 1 if the char is the ] char, 0 otherwise

\    swap the comparison value for the duplicated input char

'[-! push a 1 if the char is the [ char, 0 otherwise

-    subtract the two comparison values. If the second one is 1, the first is 0, 
     so the result is -1. Else if the second one is 0, the first is 1 and the result is
     1. Else, the first and the second are both 0 and the result is 0

+    Add the number to the counter (which is 0 if there is none already)

:0`  test if the counter is positive (that'd mean an invalid program). Pushes a 1 if 
     positive, 0 otherwise.

j#q  if the counter is positive, then this jumps to the q. Otherwise, it skips the q 
     and continues to the ~ at the beginning of the line. If there are no more chars in
     the input, then the IP will be sent back to the q.

qप्रोग्राम को क्विट करता है और एक त्रुटि मान के रूप में शीर्ष मूल्य को पॉप करता है। त्रुटि मान -1 1 होगा यदि बहुत अधिक हैं ], 0 यदि वे संतुलित हैं, और ~~सकारात्मक~~ नकारात्मक हैं यदि बहुत अधिक हैं [। नंबर है, तो ~~सकारात्मक~~ नकारात्मक है, तो ~~यह है कि कई~~ कि संख्या का निरपेक्ष मान ]के कार्यक्रम को संतुलित करने की जरूरत है।

संपादित करें: बढ़ी हुई वेतन वृद्धि और गिरावट। [काउंटर को बढ़ाने के लिए ]इस्तेमाल किया और इसे बढ़ाने के लिए इस्तेमाल किया। इसे स्विच करके, मैं 1 char को बचाता हूं, क्योंकि बाहर निकलने की स्थिति के लिए, मुझे केवल यह जांचना होगा कि काउंटर पॉजिटिव है, बजाय नकारात्मक।

पुराना संस्करण

~:'[-!j;\1+\#;']-!j;1-#;:0\`j#q

यह कोड निम्नानुसार काम करता है:

~    read one char of input
:    duplicate it
'[-! push 1 if the character is [, 0 otherwise
j    jump that number of characters
;    skip until next ;
\1+\ increment counter

similarily for ].

#q when end of input is reached, ~ reflects the IP back. q ends the program with the error value on the stack.

संपादित करें: एहसास हुआ कि यह स्वीकार किए गए इनपुट की तरह है ][, अब यह समाप्त हो जाता है जब भी गिनती नकारात्मक हो जाती है, का उपयोग करते हुए

:0\`j

— जस्टिन
स्रोत

1

18 बाइट्स

— जो किंग

@JoKing यह बहुत अच्छा है, दोनों के बीच की दूरी का उपयोग करना [और ]दोनों के साथ तुलना करना।

— जस्टिन

6

जे ( 38 35)

exit({:+.<./)+/\+/1 _1*'[]'=/1!:1[3

स्पष्टीकरण:

1!:1[3: स्टडिन पढ़ें
'[]'=/: एक मैट्रिक्स बनाएं जहां पहली पंक्ति [इनपुट में एस का एक बिटमास्क है , और दूसरी पंक्ति ]एस है।
1 _1*: पहली पंक्ति को 1 से गुणा करें और दूसरी पंक्ति को -1 से।
+/: मैट्रिक्स के स्तंभों को एक साथ जोड़कर, प्रति वर्ण डेल्टा-इंडेंटेशन देना
+/\: इनमें से एक रनिंग टोटल बनाएं, प्रत्येक वर्ण पर इंडेंटेशन स्तर दें
({:+.<./): अंतिम तत्व ( {:) और सबसे छोटे तत्व ( <./) का GCD लौटाएं । यदि सभी ब्रेसिज़ मेल खाते हैं, 0तो इन दोनों को ऐसा होना चाहिए ताकि यह वापस आ जाए 0। यदि ब्रेसिज़ मेल नहीं खाते हैं, तो यह एक नॉनज़रो वैल्यू लौटाएगा।
exit: उससे बाहर निकलने का मान निर्धारित करें और बाहर निकलें।

— मारीनस
स्रोत

अच्छा ब्रेकडाउन ...

— क्रिस कैशवेल

6

माणिक (64)

exit $<.read.tr('^[]','').tap{|x|0while x.gsub!('[]','')}.empty?

पहले (68) यह था:

exit ARGF.read.tr('^[]','').tap{|x| 0 while x.gsub!('[]','')}.empty?

एक और समकक्ष समाधान का उपयोग करता है

exit $<.read.tr('^[]','').tap{|x|0while x.gsub!('[]','')}.size>0

sizeअकेले उपयोग नहीं कर सकते क्योंकि यह झूठी नकारात्मक (!!!) देगा जब असंतुलित कोष्ठक की कुल संख्या 256 से अधिक है

— फिर से लिखा
स्रोत

यह कोडगोल्फ है। मुझे यकीन है कि आप यहां कुछ व्हाट्सएप हटा सकते हैं। रूबी कुछ हद तक व्हाट्सएप संवेदनशील है, लेकिन यह कई मामलों में इसे अनदेखा करता है। आरंभ करने के लिए, आपको =ऑपरेटर के पास व्हाट्सएप की आवश्यकता नहीं है ।

— कोनराड बोरोस्की

बेहतर संस्करण (कुछ हद तक sed + tr समाधान से प्रेरित)। मुझे यकीन नहीं है कि मैं इससे बेहतर कर सकता हूं। कम से कम यह 4 व्हाट्सएप जितना कम है!

— फिर से लिखा

1

और फिर भी, मैं उनमें से दो को हटा सकता हूं।

— कोनराड बोरोस्की

2

मुझे लगता है कि चारों ओर रिक्त स्थान 0जा सकते हैं।

— मारिनस

भयानक अंतरिक्ष चाल, धन्यवाद!

— फिर से लिखा

5

पर्ल, 30 अक्षर

बचाव के लिए आपका मूल पर्ल रिकर्सिव रेगेक्स:

perl -0ne 'exit!/^(([^][]|\[(?1)\])*)$/'

यहां उपयोग किए जाने वाले कमांड-लाइन तर्कों से अपरिचित लोगों के लिए: -0फ़ाइल इनपुट के प्रयोजनों के लिए लाइन-एंडिंग कैरेक्टर सेट करने की अनुमति देता है; -0बिना किसी तर्क के उपयोग करने से EOF पर लाइन-एंडिंग कैरेक्टर सेट हो जाता है। -nस्वचालित रूप से इनपुट (इस मामले में, संपूर्ण फ़ाइल) में पढ़ता है$_ पहले ही लेता है।

यदि रेगेक्स मेल खाता है, तो यह एक सही मूल्य देता है, जो कि बाहर निकलने वाले कोड के लिए 0 पर नकारात्मक है। अन्यथा, गलत रिटर्न मान 1 का एक निकास कोड प्राप्त करता है।

— रोटी का डिब्बा
स्रोत

मुझे लगता है कि मैं इस 30 चार्ट समाधान को हरा करने के लिए मेरे जवाब को बेहतर ढंग से गोल्फ कर दूंगा।

— जस्टिन

वहाँ। मेरा समाधान अब पहले की तुलना में बहुत छोटा है। अच्छा समाधान है। +1

— जस्टिन

4

bash (tr + sed) - 42

[ -z `tr -Cd []|sed ":a;s/\[\]//g;t a"` ]

यदि आपको त्रुटि संदेश बुरा नहीं लगता है, तो आप अंतिम स्थान को हटा सकते हैं `और ]लंबाई 41 प्राप्त कर सकते हैं ।

— shiona
स्रोत

जब तक मैं कुछ भी याद नहीं करता, आपके पास ( catऔर $()यह भी "[]"लिखा जा सकता है []) का बेकार उपयोग है । मैंने इस उत्तर को स्वीकार कर लिया है, लेकिन जब तक मैं लंबाई में सुधार नहीं देखूंगा, मैं इसे नहीं बढ़ाऊंगा, जबकि संक्षेप में, यह बैश के लिए छोटा हो सकता है।

— कोनराड बोरोस्की

ठीक है, वास्तव में मुझे पता नहीं है कि शेल स्क्रिप्टिंग अच्छी तरह से। मैं उन अधिकांश कामों को करने में असमर्थ हूं। मैंने $()backticks से बदल दिया और "[]"-> []आपने सुझाव दिया।

— शियाणा

बिल्ली का उपयोग अभी भी बेकार है ।

— कोनराड बोरोस्की

1

मेरे पास तलवार हो सकती है मैंने कोशिश की और यह विफल रहा, लेकिन मैं गलत था।

— शियोना

3

पर्ल (56 वर्ण)

$/=0;$r=qr/[^][]*(\[(??{$r})\])*[^][]*/;<>=~m/^$r$/||die

स्पष्ट पर्ल समाधान: एक पुनरावर्ती रेगेक्स। दुर्भाग्य से यह एक बल्कि क्रिया निर्माण है।

— पीटर टेलर
स्रोत

3

हास्केल (143)

import System.Exit
f=exitFailure
v c []|c==0=exitSuccess|True=f
v c (s:t)|c<0=f|s=='['=v(c+1)t|s==']'=v(c-1)t|True=v c t
main=getContents>>=v 0

जगन के लिए: 2 गार्ड का उपयोग करना, अगर-और-की तुलना में अधिक सघन लगता है। इसके अलावा, मुझे नहीं लगता कि आपका चेक यह बताता है कि कोष्ठक सही क्रम में हैं ("] [" पास ")

— user13350
स्रोत

ओह वाह, केवल इस टिप्पणी को देखा जब यह आज बताया गया था। मेरा कोड फिक्स्ड, लेकिन हाँ अच्छा है, गार्ड घने (+1) लगते हैं।

— 1:

3

सी, 73 64 चार्ट

ब्रेडबॉक्स के सुझावों के लिए धन्यवाद (हालांकि इसके लिए शायद काम करने के लिए थोड़ा-सा एंडियन चाहिए):

i;main(c){while(read(0,&c,1)*(i+1))i+=(c==91)-(c==93);return i;}

यह काम किस प्रकार करता है:

अंतर्निहित इंट ग्लोबल i0 से आरंभिक हो जाता है
cएक निहित इंट बन जाता है, जो argc1 हो जाता है (लेकिन हमें परवाह नहीं है, जब तक कि उच्च बिट सेट नहीं होते)
read(0,&c,1)सी के कम बाइट (थोड़ा-एंडियन आर्किटेक्चर पर) में एक एकल चरित्र पढ़ता है और ईओएफ में 0 देता है; i+1 != 0जब तक संतुलित ब्रैकेट बोली -1 नहीं जाती; उन्हें एक साथ गुणा करना एक (सुरक्षित) बूलियन के रूप में काम करता है और इससे एक कम चार लगते हैं&&
c==911 के लिए मूल्यांकन करता है '[', और c==931 के लिए मूल्यांकन करता है ']'। (कुछ फिडली बिट-फ़िडलिंग ट्रिक हो सकती है जो छोटी होगी लेकिन मैं कुछ भी नहीं सोच सकता।)
return iयदि यह संतुलित नहीं है तो स्थिति कोड 0 के साथ बाहर निकलता है, यदि यह शून्य नहीं है। रिटर्निंग -1 तकनीकी रूप से पोसिक्स का उल्लंघन करता है लेकिन वास्तव में किसी को भी इसकी परवाह नहीं है।

पुराना वर्जन:

main(i){char c;i=0;while(read(0,&c,1)*(i+1))i+=(c==91)-(c==93);return i;}

— शराबी
स्रोत

getchar()पढ़ने के बजाय का उपयोग करने से कोड छोटा हो जाएगा और आप अपने चर के intबजाय (अंतर्निहित) का उपयोग करने की अनुमति देंगे char। यह भी याद रखें कि ग्लोबल्स स्वचालित रूप से शून्य से शुरू होते हैं।

— ब्रेडबॉक्स

धन्यवाद, मैं getchar के बारे में भूल गया ()। यह सुनिश्चित नहीं है कि वैश्विक init कैसे मदद करता है, हालांकि - एक वैश्विक int को परिभाषित करना मैं निहित argc एक का उपयोग करने की तुलना में अधिक वर्ण लेता है।

— शराबी

1

ग्लोबल्स भी निहित हो सकते हैं। एक समारोह के बाहर c;एक वैश्विक अंतर को परिभाषित करता है।

— ब्रेडबॉक्स

इस बीच, getchar (c) इसे किसी भी तरह से छोटा नहीं बनाता है, कम से कम इस दृष्टिकोण का उपयोग करते हुए, क्योंकि इसे किसी तरह से> = 0 के लिए परीक्षण करने की आवश्यकता होती है, और सी के लिए एक अंतर्निहित int पढ़ने में () की गारंटी नहीं है। धीरज के कारण काम करते हैं।

— शराबी

किस बारे में ][? मुझे यकीन है कि यह संतुलित नहीं है। क्या आपको नज़र रखने की ज़रूरत नहीं है कि क्या यह कम से कम एक बार नकारात्मक हो जाता है?

— vsz

2

लुआ, ५६

os.exit(("["..io.read"*a".."]"):match"^%b[]$"and 0 or 1)

— mniip
स्रोत

"^%b[]$"यह क्या है? क्या तुम समझा सकते हो? निश्चित रूप से, यह रेगेक्स नहीं है?

— क्रंचर

@ क्रंचर: यह नहीं है। यह Lua पैटर्न है, रेगेक्स नहीं (Lua पैटर्न regexes के समान हैं, लेकिन वे नहीं हैं)। इस मामले में यह स्ट्रिंग की शुरुआत ( ^), संतुलित सेट के साथ [और ]कुछ इनबेटीवन ( %b[]), और स्ट्रिंग के अंत ( ) के साथ मेल खाता है $।

— कोनराड बोरोस्की

1

जीटीबी , 55

0→O:0→X[`I@I="[":X+1→X@I="]":X-1→X@X<0:1→O@!!Ig;e]l;e~O

छूट जाए []

0रोकने के लिए उपयोग करें ।

— Timtech
स्रोत

1

मैथेमेटिका, 88 वर्ण

s = "[ [ my crazy code ] [ don't explode please! [] [ :)Ahh) ]  [] []]]";

r=StringReplace;
StringLength@FixedPoint[r[#,"[]"-> ""]&,r[s,Except@Characters["[]"]-> ""]]

— Murta
स्रोत

फ़ंक्शन s name like RegularExpression` के साथ और StringLengthमैं कभी भी गणित के साथ पाठ कोड गोल्फ संदर्भ नहीं जीत सकता! :)

— मुर्त

मुझे पता है कि आपका क्या मतलब है :) साथ ही साथ ToCharacterCodeबहुत लंबा है ord... PS: एक निकास कोड सेट करने के बारे में क्या?

— अजासजा

Length[StringCases[s,"["|"]"]//.{x___,"[","]",y___}:>{x,y}]

— एलेफाल्पा

1

माणिक, 59 58

ब्रैकेट खोलने और बंद करने के लिए स्कैन, [1 और 1 के रूप में गिनती ], और बाहर निकलता है अगर गिनती 0 से नीचे गिरती है।

b=0
$<.read.scan(/\]|\[/){exit 1if(b+=92-$&.ord)<0}
exit b

— daniero
स्रोत

1

अपवित्र, और एक चरित्र से छोटा ( exit 1अगर आप पूछें तो मैंने व्हाट्सएप हटा दिया )।

— कोनराड बोरोस्की

1

हासियम , 104 बाइट्स

func main(){l=0;r=0;b=input();foreach (c in b){if(c=="[")l++;if(c=="]")r++;}if(!(r==l))exit(1);exit(0);}

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

— जैकब मिसिरियन
स्रोत

1

ट्यूरिंग मशीन कोड, 286 276 बाइट्स

फिर से, मैं यहाँ परिभाषित नियम सारणी का उपयोग कर रहा हूँ ।

0 * * l 1
1 _ ! r Q
5 _ _ r 5
5 * * * W
W [ ! l E
W ] ! l T
W _ _ l I
W * ! r *
E ! ! l *
E * * * R
R _ [ r O
R * * l *
T ! ! l *
T * * * Y
Y _ _ r U
Y * * l *
U [ _ r O
U ! ! * halt-err
I ! ! l *
I _ _ r halt
I * * l halt-err
O ! ! r Q
O _ _ l I
O * * r *
Q ! ! r *
Q * * * W

haltइनपुट स्वीकार करने और halt-errइसे अस्वीकार करने के लिए राज्य में निर्देश ।

— SuperJedi224
स्रोत

halt-errhalt*उदाहरण के लिए जैसे छोटा हो सकता है ।

— आउटगोल्फर

1

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

Ilzv::z"[^[\]]"k"]\[""],[

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

पायथन 3 अनुवाद:

import re
z=input()
if len(z):
 print(eval(re.sub("]\[","],[",re.sub("[^[\]]","",z))))

— hakr14
स्रोत

1

हास्केल ( 167 , 159)

क्या यह ज्यादातर मज़े के लिए होता है, अगर किसी को इसे छोटा बनाने के लिए कोई सुझाव मिला है, तो मुझे उन्हें सुनकर खुशी होगी :)

import System.Exit
p x y b|b=x|True=y
main=getContents>>=(return.all (>=0).scanl (\v->p (v-1) (v+1).(==']')) 0.filter (`elem`"[]"))>>=p exitSuccess exitFailure

संपादित करें: फिक्स्ड एक मुद्दा टिप्पणी में मुझे बताया (11 बाइट्स जोड़ा गया)।

संपादन 2: परीक्षण के लिए बनाया गया सहायक फंक्शन 8 बाइट्स हटाकर user13350 से प्रेरित गार्ड का उपयोग करके भविष्यवाणी करता है।

— jgon
स्रोत

के लिए विफल][ ( user13350 द्वारा बताया गया )

— user202729

@ user202729 यह एक उत्कृष्ट बिंदु है, जो सुपर लापरवाह था। बहुत यकीन है कि यह अब तय हो गया है।

— 1:

1

स्टेक्स , 14 11 वर्ण

╬Äτ↔EªÉs «Ü

इसे चलाएं और डीबग करें

-3 बाइट्स के लिए @recursive को क्रेडिट।

ASCII समकक्ष:

.[]Y|&{yz|egp!

को छोड़कर सभी वर्णों को निकालें [], तब []तक निकालें जब तक कि स्ट्रिंग बदल न जाए। 1यदि अंतिम स्ट्रिंग खाली है तो वापस लौटें ।

— वीजुन झोउ
स्रोत

1

अच्छा लगा। आप .[]|&वर्णों को फ़िल्टर करने के लिए उपयोग कर सकते हैं , और फिर 11 के

— पुनरावर्ती

ब्रेनफैक कार्यक्रम सत्यापित करें

GolfScript, 18 वर्ण

स्पष्टीकरण:

ब्रेनफक 76 बाइट्स

Befunge 98 - 26 31 20 19 वर्ण

जे ( 38 35)

माणिक (64)

पर्ल, 30 अक्षर

bash (tr + sed) - 42

पर्ल (56 वर्ण)

सी, 73 64 चार्ट

लुआ, ५६

जीटीबी , 55

मैथेमेटिका, 88 वर्ण

माणिक, 59 58

हासियम , 104 बाइट्स

ट्यूरिंग मशीन कोड, 286 276 बाइट्स

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

हास्केल ( 167 , 159)

स्टेक्स , 14 11 वर्ण