एक ढेर बिल्लियों कार्यक्रम को समतल करें

Question

स्टैक कैट्स एक प्रतिवर्ती, स्टैक-आधारित भाषा है। इसकी प्रतिवर्ती प्रकृति कुछ अजीब छोरों के लिए बनाती है। यह चुनौती सशर्त लूप के बारे में है (...)। जब इन छोरों को कुछ तरीकों से घोंसला बनाया जाता है, तो घोंसले की गहराई को कम करने के लिए कोड को बदलना संभव है। यहां नियम हैं (जहां Aऔर Bमनमाने ढंग से स्निपेट के लिए खड़े हैं):

1. जब एक लूप दूसरे लूप से शुरू होता है, तो हम आंतरिक लूप को सामने की तरफ निकाल सकते हैं: ((A)B)बन जाता है (A)(B)।
2. जब एक लूप दूसरे लूप के साथ समाप्त होता है, तो हम आंतरिक लूप को अंत तक निकाल सकते हैं: (B(A))बन जाता है (B)(A)।
3. खाली छोरों, ()को कार्यक्रम से पूरी तरह से हटाया जा सकता है। एक कोरोलरी के रूप में (अन्य नियमों के साथ संयोजन के रूप में), ((A))समकक्ष है (A)।

एकमात्र नेस्टेड लूप जो बने रहेंगे (A(B)C), फॉर्म के हैं , जहां A, Bऔर Cगैर-खाली हैं।

चुनौती

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

एक मान्य स्टैक कैट्स प्रोग्राम ...

• ... केवल पात्रों के होते हैं ()/\<>[]{}!"*+-:=ITX^_|।
• ... दर्पण समरूपता है (उदाहरण के \(]{}!{}[)/लिए एक वैध कार्यक्रम है, लेकिन /|/नहीं है)।
• ... सही ढंग से मिलान और नेस्टेड है ( ()और , और हमेशा की तरह मिलान करने की आवश्यकता नहीं है, हालांकि वे दर्पण समरूपता की आवश्यकता के कारण जोड़े में दिखाई देंगे)।{}[]<>\/

आप इनपुट के रूप में या तो एक स्ट्रिंग या वर्णों की सूची ले सकते हैं, लेकिन आउटपुट को उसी प्रारूप में प्रस्तुत करना होगा।

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं। ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया जाता है।

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

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

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

(((=+|+=)))
(=+|+=)

({(=+|+=)})
({(=+|+=)})

((\)/)I(\(/))
(\)(/)I(\)(/)

(()()(())()())


((<|>((X((T)))[_]))\^/(([_](((T))X))<|>))
(<|>)(X)(T)([_])(\^/)([_])(T)(X)(<|>)

Comments

सिर्फ यह सुनिश्चित करने के लिए कि हमारे पास जो लूप्स निकालने हैं, वे केवल कोष्ठक द्वारा इंगित किए जाते हैं (), इसलिए एक इनपुट {{A}B}जैसा रहेगा और {A}{B}वैसे ही नहीं निकाला जाएगा ?

— केविन क्रूज़सेन

@ केविनक्रूजसेन हाँ, परिवर्तन केवल (...)लूप के लिए मान्य है ।

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

अंतिम परीक्षण मामले में, \^/कोष्ठक के अंदर क्यों है ?

— केविन क्रूज़सेन

@KevinCruijssen आप निकालने के बाद सबसे बाहरी कोष्ठक हैं (<|>((X((T)))[_]))और (([_](((T))X))<|>)।

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

ओह समझा। तो बाद में नियम 1 और 2 दोनों के कारण ((A)B(C))बन जाएगा (A)(B)(C): ((A)B(C))→ (A)(B(C))(नियम 1) → (A)(B)(C)(नियम 2)।

— केविन क्रूज़सेन

Answer 1

रेटिना 0.8.2 , 113 107 67 66 बाइट्स

+`\(\)|(\()?(\(((\()|(?<-4>\))|[^()])*(?(4)@)\))(?(1)|(\)))
$5$2$1

इसे ऑनलाइन आज़माएं! @MartinEnder के लिए 3 4 बाइट बचत धन्यवाद शामिल हैं । स्पष्टीकरण:

+`

जब तक कोई मेल न हो तब तक प्रतिस्थापन को लागू करें।

\(\)|

एक खाली लूप से मिलान करें (जिस स्थिति में कुछ भी कब्जा नहीं किया जाता है, इसलिए प्रतिस्थापन बस इसे हटा देता है) या:

(\()?

वैकल्पिक रूप से एक मैच (। यदि यह मेल खाता है, तो यह समूह 1 में कैद है, लेकिन ऐसा नहीं है।

(\(

समूह 2 में मैच के मुख्य निकाय पर कब्जा करें और मैच करें (।

(
 (\()
|
 (<-4>\))
|
 [^()]
)*

बार-बार मैच या तो ए (, इसे ग्रुप 4 में कैप्चर करना, या ए ), ग्रुप 4 से कैप्चर हटाना (यदि एक नहीं है तो फेल होना), या कुछ और।

(?(4)@)

सुनिश्चित करें कि समूह 4 में कोई अतिरिक्त कब्जा नहीं बचा है।

\))

दूसरे के साथ समूह 2 पर कब्जा करें )।

(?(1)|(\)))

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

$5$2$1

समूह 2 के दूसरे पक्ष में समूह 1 या समूह 5 में कैप्चर किए गए ब्रैकेट को ले जाएं। इसमें आंतरिक लूप को सामने या बाहरी लूप के अंत तक ले जाने का प्रभाव होता है, जिसके आधार पर यह मेल खाता है।

Answer 2

Stax v1.0.3 +, 76 65 64 62 58 बाइट्स ^CP437

îÜ•$o,Γ{í]Üf╒9♦╛üΣóç*\$ñ₧└ΦJ♠¥c╥jóu≥3E.╘ⁿ◄◘W₧<¶┼7úê╟┴zç↨aG

70 बाइट्स जब अनपैक किए जाते हैं,

{{.((:/Yc{Z{40=+_41=-c^Ci~^Fdy,,\32&jEa:{a:{a4l$c}Md}X!:Rx!:Rc.()z:rgp

भागो और डिबग ऑनलाइन!

व्याख्या

{.((:/Yc{Z{40=+_41=-c^Ci~^Fdy,,\32&jEa:{a:{a4l$c}Mdएक ऐसा ब्लॉक है जो A((B)C)Dचार भागों में अलग हो जाता है और इसे रूपांतरित करता है A(B)(C)D।

X!:Rx!:Rइनपुट स्ट्रिंग (चरण 1) पर ब्लॉक को निष्पादित करता है, फिर स्ट्रिंग को दर्शाता है (Stax में स्ट्रिंग प्रतिबिंब को संदर्भित करता है स्ट्रिंग को बदलने के (<[{/साथ-साथ ( अनुवाद करना) \}]>)) और प्राप्त स्ट्रिंग पर ब्लॉक को निष्पादित करता है, और फिर इसे वापस प्रतिबिंबित करता है। (चरण 2)। चरण 2 अनिवार्य रूप से परिवर्तित (A(B))हो रहा है (A)(B)।

c.()z:r सभी खाली छोरों को हटा दें (चरण 3)।

gpएक जनरेटर है जो एक पुनरावृत्ति का फिक्स बिंदु पाता है। इस स्थिति में स्ट्रिंग को 3-चरण प्रक्रिया के साथ पुनरावृत्त किया जाता है जब तक कि यह अब नहीं बदलता है।

निहित उत्पादन।

Answer 3

पायथन 3 , 226 223 212 206 बाइट्स

ठीक है, यहाँ इसे एक ऐसी भाषा में हल करने का प्रयास किया गया है जो पुनरावर्ती रेगेक्स का समर्थन नहीं करता है।

lambda s:g(g(s,*'()'),*')(').replace('()','')
def g(s,t,u):
 m,*a={},;i=v=0
 for c in s:
  i+=1;a+=[i]*(c==t)
  if c==u:*a,x=a;m[x]=i;v=m.get(x+1)
  if v:return g(s[:x]+s[x+1:v]+t+s[v:],t,u)
 return s[::-1]

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

संपादन:

• पुनर्संशोधित [::-1]6 बाइट्स, Mr.Xcoder करने के लिए धन्यवाद को बचाने के लिए।

gसमारोह मूल निर्माण खंड है, जिनमें से एक घटना पाता है ((A)B), बदलता है यह करने के लिए (A)(B)है, तो अपने आप में परिणाम पर लागू होता है जब तक कोई और अधिक परिवर्तन संभव है।

मुख्य चरण हैं:

• gइनपुट पर सामान्य रूप से लागू करें ।
• लागू gइनपुट फ़्लिप करने के लिए। यह रन ))A(B(उलट इनपुट की घटना को ढूंढता है , जो प्रभावी रूप से संभालता है (A(B))।
• की किसी भी घटना को दूर करें ()।

समस्या यह है gकि इतनी खराब नियंत्रण संरचना है कि एक-लाइन की कोशिश करने से यह बुरी तरह से फूल गई है, इसलिए मुझे नहीं लगता कि इस समाधान के आधार पर प्रमुख सुधार संभव है।