पूरी तरह से अभिव्यक्त भाव

Question

आज आपकी चुनौती एक अभिव्यक्ति के सभी संभव पूर्ण कोष्ठक का निर्माण करना है।

आपका इनपुट प्रिंट करने योग्य ASCII की एक एकल पंक्ति है जिसमें ऑपरेटरों द्वारा एक या एक से अधिक शब्द हैं। इनपुट में रिक्त स्थान भी हो सकते हैं - आपको इन पर ध्यान नहीं देना चाहिए। एक शब्द है [a-zA-Z0-9], एक ऑपरेटर है [^ ()a-zA-Z0-9]। आप मान सकते हैं कि इनपुट हमेशा मान्य है।

वैकल्पिक अनुरेखण न्यूलाइन के साथ newlines द्वारा अलग-अलग दिए गए अभिव्यक्ति को पूरी तरह से छोटा करने के लिए सभी संभव तरीकों को आउटपुट करें।

क्या नहीं :

• कोष्ठक की शर्तें - केवल ऑपरेटरों के आसपास कोष्ठक।
• शर्तों को फिर से व्यवस्थित करें।
• किसी भी रिक्त स्थान को आउटपुट करें।

उदाहरण इनपुट / आउटपुट:

N
N

a * b
(a*b)

x_x_0
(x_(x_0))
((x_x)_0)

a * b|c|d
(a*(b|(c|d)))
(a*((b|c)|d))
((a*b)|(c|d))
((a*(b|c))|d)
(((a*b)|c)|d)

---

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

आपको उन सटीक ऑपरेटरों को सूचीबद्ध करना होगा जिन्हें हमें विचार करना है। है !एक ऑपरेटर? किस बारे में ↑?

— ऑप्टिमाइज़र

@Optimizer मैंने एक ऑपरेटर माना जाता है की सटीक नियमित अभिव्यक्ति सूचीबद्ध की। !रेगेक्स फिट बैठता है, इसलिए ↑, हालांकि ↑इनपुट का हिस्सा नहीं हो सकता है क्योंकि यह मुद्रण योग्य एएससीआईआई नहीं है।

— orlp

आह ठीक है। एक टर्म को छोड़कर कुछ भी एक ऑपरेटर है ...

— ऑप्टिमाइज़र

तो क्या पद और परिचालक दोनों हमेशा एक वर्ण के होते हैं?

— user81655

यहां अनिवार्य LISP- संबंधित वाक्य डालें

— बिल्ली

Answer 1

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

L?tbsmmjj@bdk"()"*y<bdy>bhd:1lb2bjy-zd

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

यह एक पुनरावर्ती कार्य को परिभाषित करता है:

• इनपुट लौटाता है यदि इसकी लंबाई 1 है
• ऑपरेटरों पर इनपुट के सभी दो-विभाजन करता है, और प्रत्येक विभाजन के लिए:
  • प्रत्येक पड़ाव पर खुद को पुनरावर्ती कहता है
  • प्रत्येक आधे के परिणामों का कार्टेशियन उत्पाद लेता है
  • विभाजन पर ऑपरेटर द्वारा प्रत्येक परिणाम में शामिल होता है
  • सम्मिलित परिणाम को कोष्ठक करता है
• और अंत में परिणामी सरणियों को समेटता है।

फिर फ़ंक्शन को हटाए गए रिक्त स्थान के साथ इनपुट स्ट्रिंग के साथ बुलाया जाता है और परिणाम newlines द्वारा जुड़ जाते हैं।

Answer 2

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

s=>((q=x=>x.map((_,i)=>(a=[...x.slice(0,i*=2),p="("+x[i]+x[++i]+x[++i]+")",...x.slice(i+1)],x[i]?a[1]?q(a):r.push(p):0)))([...s.replace(/ /g,o="")],r=[]),r.map((l,i)=>r.indexOf(l)<i?0:o+=l+`
`),o)

व्याख्या

एक पुनरावर्ती फ़ंक्शन का उपयोग करता है जो एक सरणी लेता है [ t, o, t, o, etc... ]और प्रत्येक दो जोड़े की लगातार जोड़ी को एक साथ जोड़ देता है जैसे कि [ (tot), o, etc... ]इस प्रक्रिया को दोहराता है और तब तक दोहराता है जब तक कि सरणी में केवल एक तत्व न हो, फिर डुप्लिकेट मानों को फ़िल्टर करता है।

s=>(                                  // s = input string
  (q=x=>                              // q = parenthesise array function
    x.map((_,i)=>(
      a=[                             // a = p with parenthesised pair of terms
        ...x.slice(0,i*=2),
        p="("+x[i]+x[++i]+x[++i]+")", // parenthesise and join 2 terms and an operator
        ...x.slice(i+1)
      ],
      x[i]?a[1]                       // make sure the loop is not over
        ?q(a)                         // check next level of permutations
        :r.push(p)                    // add the permutation to the results
      :0
    ))
  )([...s.replace(/ /g,               // remove spaces and parenthesise all expressions
    o="")],                           // o = output string
    r=[]),                            // r = array of result strings
  r.map(                              // filter out duplicates
    (l,i)=>r.indexOf(l)<i?0:o+=l+`
`
  ),o)                                // return o

परीक्षा

Input = <input type="text" id="input" value="a * b|c|d" /><button onclick='results.innerHTML=(

s=>((q=x=>x.map((_,i)=>(a=[...x.slice(0,i*=2),p="("+x[i]+x[++i]+x[++i]+")",...x.slice(i+1)],x[i]?a[1]?q(a):r.push(p):0)))([...s.replace(/ /g,o="")],r=[]),r.map((l,i)=>r.indexOf(l)<i?0:o+=l+`
`),o)

)(input.value)'>Go</button><pre id="results"></pre>