लागू होता है या प्रस्तुत करता है? निर्भर करता है


23

ब्रेन-फ्लैक कल एक साल का हो गया! इसके जन्मदिन के सम्मान में, हम एक PPCG स्टाइल बर्थडे पार्टी कर रहे हैं, जहाँ कई उपयोगकर्ता मस्तिष्क से संबंधित संबंधित पोस्ट करते हैं! हमें मनाने में मदद करें! :)


ब्रेन-फ्लैक एक गूढ़ भाषा है जिसे मैंने लिखा था कि सभी कमांड कोष्ठक हैं और सभी कोष्ठक पूरी तरह से मेल खाने चाहिए। मेरी अपनी परिभाषा उधार लेने के लिए :

  • इस चुनौती के उद्देश्य के लिए, "ब्रैकेट" इन वर्णों में से एक है: ()[]{}<>

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

    ()
    []{}
    

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

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

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

    [(){<><>[()]}<>()]
    <[{((()))}]>
    
  • एक स्ट्रिंग माना जाता है "पूरी तरह से मिलान" अगर और केवल अगर:

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

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

ब्रेन-फ्लैक के पहले जन्मदिन के उपलक्ष्य में, आज की चुनौती कोष्ठक के असंतुलित सेट लेने के बारे में है, और यह निर्धारित करने के लिए कि इसे मान्य मस्तिष्क-फ्लैक बनाने के लिए किस प्रकार के संचालन की आवश्यकता है।

  • उदाहरण के लिए, ((मान्य मस्तिष्क-फ्लैक कोड नहीं है, लेकिन अगर हम ))इसे जोड़ते हैं, तो यह बन जाता है (()), जो पूरी तरह से संतुलित है, और इसलिए मान्य मस्तिष्क-फ्लैक है। जो इस इनपुट को उपयुक्त बनाता है ।

  • इसी तरह, >}मान्य नहीं है, लेकिन हम {<इसे बनाने के लिए प्रस्तुत कर सकते हैं {<>}, जो वैध है। जो इस इनपुट को प्रीपेन्डेबल बनाता है ।

  • कुछ इनपुट थोड़े अधिक जटिल हैं। उदाहरण के लिए, )][({जोड़कर या पूर्वसर्ग करके शुद्ध रूप से वैध नहीं बनाया जा सकता है। लेकिन इसे तैयार करने और जोड़कर वैध बनाया जा सकता है । इसलिए, यह इनपुट प्रीपेन्डेबल और एपेंडेबल दोनों है[(})]

  • अन्त में, कुछ इनपुट्स को कभी भी जोड़-तोड़ या प्रीपेडिंग के संयोजन द्वारा मान्य ब्रेन-फ्लैक कोड नहीं बनाया जा सकता है। उदाहरण के लिए, (>कभी भी वैध नहीं बनाया जा सकता। (Prepending <बनाता है <(>, और appending )बनाता है (>), न तो जिनमें से मान्य हैं) इसलिए, इस इनपुट न appendable या prependable है।

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

appendable
prependable
both
neither

प्रत्येक मामले के प्रतिनिधित्व के लिए आप किन मूल्यों का उपयोग कर सकते हैं। उदाहरण के लिए, आउटपुट 1, 2, 3, 4, 'a', 'p', 'b', 'n'या 1, 'foo', 3.1415, -17, या जो भी ठीक है। जब तक प्रत्येक आउटपुट अलग और सुसंगत है , तब तक ठीक है। आप चाहिए हालांकि, स्पष्ट रूप से जो उत्पादन मेल खाती है जो मामले को निर्दिष्ट करें।

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

आप मान सकते हैं कि इनपुट मान्य ब्रेन-फ्लैक या खाली कभी नहीं होगा।

उदाहरण

निम्नलिखित निविष्टियाँ सभी प्रस्तुत करने योग्य हैं :

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

ये सभी उचित हैं :

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

ये दोनों हैं :

))((
>()[(()){
>{

और ये सभी न तो हैं :

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

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


यह चुनौती ब्रेन-फ्लैक में विशेष रूप से कठिन है, इसलिए ब्रेन-फ्लैक में लिखे किसी भी और हर उत्तर के लिए अधिकतम ब्राउनी इंगित करता है। :)


1
maximum brownie pointsमुझे लगता है कि इसके बजाय अधिकतम ब्राउनी पॉइंट और कुकीज़ की पेशकश ब्रेन-फ़्लकिंग को केवल ब्राउनी पॉइंट से अधिक चुनौती देती है, क्योंकि मुझे नहीं लगता कि यह किसी भी भाषा में बिल्कुल तुच्छ है , अकेले ब्रेन-फ्लैक को छोड़ दें। : पी
एरिक आउटगॉल्फ

FYI करें: सभी दोनों परीक्षण खुले कोष्ठक के साथ समाप्त होते हैं, न तो सभी परीक्षण बंद कोष्ठक के साथ समाप्त होते हैं।
जोनाथन एलन

2
मैं तर्क दूंगा कि 'दोनों' गलत शब्द है। की तरह एक स्ट्रिंग ][है नहीं कुछ भी नहीं आप जोड़ सकते हैं के रूप में यह वैध बना सकते हैं appendable,। इसी तरह, यह प्रीपेन्डेबल नहीं है। यह ... 'डालने योग्य' है! पूरे मान्य ब्रेनफ्लक को बनाने के लिए आप इसे एक स्ट्रिंग में सम्मिलित कर सकते हैं।
orlp

पहले से ही संतुलित तार हैं या दोनों नहीं?
गेहूं जादूगर

@wheatwizard संतुलित स्ट्रिंग्स को इनपुट के रूप में नहीं दिया जाएगा। You can assume that the input will never be valid brain-flak or empty.
DJMcMayhem

जवाबों:


6

जेली , 33 32 37 35 34 बाइट्स

बग पाया, भयानक फिक्स +5 बाइट्स, बेहतर फिक्स - 2 बाइट्स, अदनान की एक चाल का उपयोग करके मैंने यहां -1 और देखा ।

“({[<“)}]>”Z;@WœṣF¥/µÐLO‘&2µIṀ>0ȯQ

वापसी मान:

prepends [2]
 appends [0]
    both [2,0]
 neither 1

(अमान्य इनपुट से शानदार परिणाम मिलते हैं, हालांकि मान्य ब्रेन-फ्लैक, रिटर्न []।)

इसे ऑनलाइन आज़माएं! - टेस्ट स्वीट (प्रिंट, अभ्यावेदन mushed इतना20के लिए[2,0], और ध्यान न लाइनों शामिल करने वाली-)।


5

रेटिना , ४१ ४० 41 बाइट्स

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

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

[]})>]+
1
\W+
0
...+
01

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

  • प्रीपेन्डेबल है 1
  • परिशिष्ट है 0
  • दोनों है 10
  • कोई नहीं है 01

संपादित करता

  • @Neil द्वारा देखे गए बग को ठीक करने के लिए 1 बाइट दिया

[]})>]एक बाइट बचाता है।
मार्टिन एंडर

@MartinEnder आह, यह है क्योंकि चरित्र सेट खाली नहीं हो सकता, धन्यवाद!
कृति लीथोस

यह सभी गैर-परिशिष्ट इनपुट के लिए काम नहीं करता है, उदाहरण के लिए (][)। मुझे लगता है कि इसे बदलकर एक बाइट की लागत पर तय किया जा सकता 101है ...+
नील

@Neil बग को सूचित करने के लिए धन्यवाद, मुझे आश्चर्य है कि अगर इस तरह के मामले Bothभी हैं
क्रिति लिथोस

नहीं, मुझे लगता 10है कि इसके लिए एकमात्र वैध संयोजन है Both
नील

3

बैच, 337 बाइट्स

@echo off
set/ps=
:g
set "t=%s:<>=%
set "t=%t:()=%
set "t=%t:[]=%
set "t=%t:{}=%
if not "%t%"=="%s%" set "s=%t%"&goto g
set "s=%s:<=[%
set s=%s:>=]%
set s=%s:(=[%
set s=%s:)=]%
set s=%s:{=[%
set s=%s:}=]%
:l
if %s:~,2%==]] set s=%s:~1%&goto l
:r
if %s:~-2%==[[ set s=%s:~,-1%&goto l
if not _%s:~2%==_ set s=[]
echo %s%

]प्रीपेंड के लिए आउटपुट [, ][दोनों के लिए, []न ही के लिए।


3

हास्केल , 115 108 बाइट्स

संपादित करें:

  • -7 बाइट्स: अधिक गार्ड का उपयोग करें।
(""#)
s#""=[s>"",1>0]
s#(c:d)|Just a<-lookup c$zip"([{<"")]}>"=(a:s)#d|(a:b)<-s=[1|a==c]>>b#d|0<1=take 1$s#d

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

का उपयोग करें (""#) "))"। परिणाम इस प्रकार हैं:

[False,True]: needs nothing
[False]: prependable
[True,True]: appendable
[True]: both
[]: neither

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

  • आउटपुट एन्कोडिंग को इस तरह से चुना जाता है कि परिणाम के दूसरे तत्व को शेष के लिए छोड़ने की आवश्यकता होती है, यदि कोई हो, तो एक पूर्ण बेमेल को उन सभी को छोड़ने का संकेत दिया जाता है।
  • s#ddएक स्ट्रिंग / स्टैक दिया, एक शेष स्ट्रिंग पार्सsअपेक्षित समापन कोष्ठक के को ।
    • s#""लाइन चेकों सब बंद करने कोष्ठक स्ट्रिंग के अंत तक पाया गया है अगर, अन्यथा जोड़कर की जरूरत है।
    • s#(c:d)अगले चरित्र की जाँच की पहली शाखाc एक खोलने वाली ब्रैकेट है, और यदि ऐसा है तो पुनरावृत्ति के लिए स्टैक पर संबंधित समापन ब्रैकेट छोड़ देता है।
    • अन्यथा, यदि स्टैक में कोष्ठक सम्‍मिलित होते हैं, तो दूसरी शाखा यह जाँचती है कि शीर्ष एक अगले वर्ण से मेल खाता है या नहीं, और यदि नहीं तो पीछे हटने के बजाय एक खाली सूची लौटाता है।
    • अंत में, पिछली शाखा में स्टैक खाली है, और हमारे पास एक बेजोड़ क्लोजिंग ब्रैकेट है, जिसे पुनरावृत्ति करने से पहले, पूर्व निर्धारित करके तय किया जा सकता है।

2

जाप , 44 बाइट्स

=Ue"%(%)|%[]|\{}|<>" ®c -1&2|1})f31 |UfD |Ug

1प्रीपेन्डेबल के लिए आउटपुट ,3 लिए, 13दोनों के लिए, और 31न ही के लिए।

इसे ऑनलाइन टेस्ट करें!या एक बार में सभी परीक्षण मामलों को सत्यापित करें।

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

 =Ue"%(%)|%[]|\{}|<>" ®   c -1&2|1})f31 |UfD |Ug
U=Ue"%(%)|%[]|\{}|<>" mZ{Zc -1&2|1})f31 |UfD |Ug

                    // "(((()()())))}"  "([({}{})"    ">()[(()){"  "((((<>()]"
Ue"%(%)|%[]|\{}|<>" // Recursively remove all instances of "()", "[]", "{}", and "<>" from U.
                    // "}"              "(["          ">[{"        "((((]"
mZ{Zc -1&2|1}       // Replace each char Z with (Z.charCodeAt() - 1) & 2 | 1.
                    // "1"              "33"          "133"        "33331"
U=                  // Save the result in U.
f31 |UfD |Ug        // Match all instances of "31" and "13" (D = 13) and bitwise-OR the results with the first char.
                    // null|null|1      null|null|3   null|13|1    31|null|3
                    // 1                3             13           31
                    // Implicit: output result of last expression

2

PHP, 137 बाइट्स

for($c=1;$c;)$a=preg_replace("#<>|\(\)|\[\]|\{\}#","",$a=&$argn,-1,$c);echo($a=preg_replace(["#[]})>]+#","#[[{(<]+#"],[1,2],$a))<13?$a:0;

1 => प्रशंसनीय,

2 => प्रीपेन्डेबल,

12 => दोनों,

0 => न ही

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


"जब तक प्रत्येक आउटपुट विशिष्ट और सुसंगत है, तब तक ठीक है"। यह न तो के लिए एक सुसंगत मूल्य प्रतीत नहीं होता है।
साइओस

@Cyoce यह अब निश्चित है
Jörg Hülsermann
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.