पैरेन्काइज्ड इन्फेंटिक्स के लिए पैनिफ़िक्स

Question

Quylthulg क्रिस Pressey की एक भाषा है जो पैन्फ़िक्स को कॉल करते हुए इनफ़िक्स नोटेशन की समस्या को हल करने का प्रयास करती है :

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

---

प्रीफ़िक्स या पोस्टफ़िक्स की असंदिग्धता के साथ आपको इन्फिक्स नोटेशन की सुविधा कैसे मिलती है? तीनों का उपयोग करें, बिल्कुल!

=y=+*3*x*+1+=

अधिक औपचारिक रूप से, चलो +एक ऑपरेटर है, और aऔर bभाव हो। फिर (a+b)एक वैध (कोष्ठक) infix अभिव्यक्ति है, उस अभिव्यक्ति का पैनिफ़िक्स प्रतिनिधित्व है +a+b+, जहां juxtaposition संघनन का प्रतिनिधित्व करता है।

आपका लक्ष्य पैन्फ़िक्स स्ट्रिंग लेना है और इसे पूरी तरह से कोष्ठक में बदलना है:

(y=((3*x)+1))

सरलता के लिए, हम निम्नलिखित बदलाव करेंगे:

• ऑपरेटर्स केवल दो अद्वितीय वर्णों से मिलकर बना सकते हैं (आप किसी भी चुन सकते हैं, लेकिन यहां मैं उपयोग करूंगा *और +)।
• केवल एक शाब्दिक है, जिसमें एक और विशिष्ट चरित्र होता है (आप किसी को भी चुन सकते हैं, लेकिन यहां मैं उपयोग करूंगा _)।
• इनपुट एक अच्छी तरह से गठित पैनफिक्स अभिव्यक्ति होगी।

के लिए जटिलता , हम निम्नलिखित परिवर्तन कर देंगे:

• ऑपरेटर्स किसी भी सकारात्मक वर्ण को शामिल कर सकते हैं , केवल एक ही नहीं।

यह चुनौती को और अधिक कठिन बना देता है क्योंकि आप आवश्यक रूप से यह निर्धारित नहीं कर सकते हैं कि ऑपरेटर वर्णों के दिए गए स्ट्रिंग को बाकी स्ट्रिंग को देखे बिना कैसे विभाजित किया जाए।

यहाँ चुनौती के लिए एक संदर्भ कार्यान्वयन है , @ user202729 के सौजन्य से।

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

format: input -> output
+*+_*+_*+++_+*+_*+_*+++ -> ((_*+_)+(_+(_*+_)))
**++*+***++_+_++_+*++*+***_*++*+*****_**_*_*** -> ((((_+_)+_)*++*+***_)*(_*(_*_)))
***_**_***_* -> ((_**_)*_)
+_+_+ -> (_+_)
*+*+++**+***+++++_*+*+++**+***+++++_*+*+++**+***+++++ -> (_*+*+++**+***+++++_)
*++++*+*_*_*+*+++****+_++****+_++****++*+*+++_*+++ -> (((_*_)+*+(_++****+_))*+++_)
+**+_*+_*+*_*+*_*+*_+*_+**+ -> (((_*+_)*_)+(_*(_+*_)))
+**+++++_+++++_+++++*_*+*+_++++++_+++++_+++++++* -> (((_+++++_)*_)+*(_+(_+++++_)))
+*+*+_+*+_+*+*_*+*_*+*+_+*+_+*+*+ -> (((_+*+_)*_)+(_*(_+*+_)))
**_**_**_*_****_* -> ((_*(_*(_*_)))*_)

मैंने इस चुनौती के लिए इन्फिक्स स्ट्रिंग्स उत्पन्न करने के लिए इस प्रोग्राम का उपयोग किया (पैनिफ़िक्स में परिवर्तित करना तुच्छ था, लेकिन उलटा नहीं है)।

Comments

उलटा

— कॉनर ओ'ब्रायन

संबंधित

— HyperNeutrino

सुझाए गए परीक्षण का मामला: **_**_**_*_****_*। मैंने जिन उत्तरों का परीक्षण किया है वे सभी इसे विफल कर चुके हैं।

— नाइट्रॉडन

क्या मेरे आउटपुट में अतिरिक्त स्थान हो सकते हैं, जैसे (_ + _)?

— टन हास्पेल

@ टोनहोस्ट ज़रूर।

— फलन

Answer 1

प्रोलोग (एसडब्ल्यूआई) , 194 163 बाइट्स

^{0 ' से इस टिप का उपयोग करके 31 बाइट्स की बचत की !}

[C|T]/O/R:-C\=x,(T/P/R,concat(C,P,O);O=C,R=T).
[x|R]-x-R.
L-X-R:-L/O/A,A-Y-B,B/O/C,C-Z-D,D/O/R,atomics_to_string(['(',Y,O,Z,')'],X).
X^P:-string_chars(X,L),L-P-[].

ऑपरेटर ^अपने बाएँ तर्क के लिए एक पैने उपसर्ग अभिव्यक्ति वाला स्ट्रिंग लेता है और इसके समतुल्य तर्क को संगत कोष्ठक प्रत्यय अभिव्यक्ति वाले स्ट्रिंग में सेट करता है। इसका उपयोग xशाब्दिक के स्थान पर किया जाता है _।

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

व्याख्या

चूँकि प्रोलॉग एक घोषित भाषा है, हमें सिर्फ एक पैनोफिक्स और एक कोष्ठक अभिव्यक्ति के बीच के संबंध का वर्णन करना है।

स्पष्टीकरण इस थोड़ा ungolfed संस्करण का उपयोग करता है:

oper([C|T],O,R) :- C\=x, oper(T,P,R), concat(C,P,O).
oper([C|T],C,T).

expr([x|R],x,R).
expr(L,X,R) :- oper(L,O,A), expr(A,Y,B), oper(B,O,C), expr(C,Z,D), oper(D,O,R),
               atomics_to_string(['(',Y,O,Z,')'],X).

parenthesize(X,P) :- string_chars(X,L), expr(L,P,[]).

हमारा मुख्य उत्पादन है parenthesize, जो एक पैनोफिक्स अभिव्यक्ति में लेता हैX रूप और एक स्ट्रिंग के रूप में संबंधित कोष्ठक को बाहर भेजता है P। यह string_charsइनपुट स्ट्रिंग को वर्णों की सूची में बदलने के लिए उपयोग करता है और फिर बस इसे पास करता है expr।

exprपात्रों की एक सूची में ले जाता है L, पहले पैनफिक्स अभिव्यक्ति को पार्स करता है जो इसे पाता है L, और कोष्ठक के समकक्ष भेजता हैX और वर्णों की सूची के शेष भाग कोR । अभिव्यक्ति के दो संभावित प्रकार हैं:

• अगर का पहला किरदार Lहैx , तो अभिव्यक्ति है xऔर शेष सब कुछ के बाद है x।
• अन्यथा, एक ऑपरेटर को पार्स करें O( operनीचे देखें); एक अभिव्यक्ति को पार्स करें Y; Oफिर से पार्स करें; एक और अभिव्यक्ति को पार्स करें Z; और Oतीसरी बार पार्स करें । तीसरे उदाहरण के बाद शेष सब कुछ है O। अभिव्यक्ति में शामिल होने का परिणाम है Y,O और Z, कोष्ठक से घिरा हुआ एक स्ट्रिंग में,।

operपात्रों की एक सूची में ले जाता है, जहां पहला चरित्र है Cऔर बाकी हैं T; यह एक ऑपरेटर को पार्स करता है (यानी एक या एक से अधिक ऑपरेटर वर्णों का) और ऑपरेटर Oऔर पात्रों की सूची के शेष भाग को भेजता है R। एक ऑपरेटर बनाने के लिए, चरित्र के Cअलावा कुछ और होना चाहिए x; भी, या तो

• एक ऑपरेटर Pको Tशेष के साथ से पार्स करने योग्य होना चाहिए R; इस मामले में,O के संयोजन है Cऔर P; या,
• Oएकल चरित्र है C; इस मामले में, Rबस हैT ।

एक उदाहरण काम किया

+*+x+x++*x+*एक उदाहरण के लिए इनपुट लेते हैं ।

• हम एक अभिव्यक्ति को पार्स करना चाहते हैं +*+x+x++*x+*। इससे शुरू नहीं होता हैx , इसलिए हम शुरू से ही एक ऑपरेटर को पार्स करते हैं।
• oper जितना संभव हो उतना बड़ा ऑपरेटर होगा, इसलिए हम कोशिश करते हैं +*+ ।
  • आगे हम एक अभिव्यक्ति को पार्स करते हैं x+x++*x+*। यह होना ही हैx ।
  • अब हम, एक ही ऑपरेटर पार्स करने के लिए कोशिश +*+से, +x++*x+*। हालाँकि, यह विफल रहता है ।
• तो हम पीछे चलते हैं और +*इसके बजाय ऑपरेटर को पार्स करने का प्रयास करते हैं।
  • हम से एक अभिव्यक्ति पार्स +x+x++*x+*। यह शुरू नहीं होता है x, इसलिए हमें एक ऑपरेटर को पार्स करने की आवश्यकता है।
  • एकमात्र संभावना है +।
  • अब से एक सबडिस्पेशन को पार्स करें x+x++*x+*। यह होना ही है x।
  • अब +फिर से पार्स करें +x++*x+*।
  • अब से एक और सबडिप्रेशन को पार्स करें x++*x+*। यह होना ही है x।
  • अंत में, +फिर से पार्स करें ++*x+*।
  • अभिव्यक्ति को सफलतापूर्वक पार्स किया गया है। हम स्ट्रिंग वापस करते हैं (x+x)।
• पिछले पुनरावृत्ति स्तर पर वापस, हम ऑपरेटर को +*फिर से पार्स करते हैं +*x+*।
• अब से एक और सबडिप्रेशन को पार्स करें x+*। यह होना ही है x।
• अंत में, +*फिर से पार्स करें +*।
• अभिव्यक्ति को सफलतापूर्वक पार्स किया गया है। हम स्ट्रिंग वापस करते हैं ((x+x)+*x)।

चूँकि अधिक वर्ण शेष नहीं हैं, हमने अभिव्यक्ति का सफलतापूर्वक अनुवाद किया है।

Answer 2

पर्ल, 78 60 58 57 50 बाइट्स

शामिल +1 हैp

के 1लिए +और के 2लिए उपयोग करता है *(या वास्तव में किसी भी ऑपरेटर के लिए कोई अंक काम करता है)

perl -pe 's/\b((\d+)((?1)|_)\2((?3))\2)\b/($3 $2 $4)/&&redo' <<< 22_22_22_2_2222_2

दिए गए उदाहरणों के लिए सुविधाजनक परीक्षण के लिए आप इसका उपयोग कर सकते हैं जो आपके लिए अनुवाद और स्थान को हटाने का काम करता है:

perl -pe 'y/+*/12/;s/\b((\d+)((?1)|_)\2((?3))\2)\b/($3 $2 $4)/&&redo;y/ //d;y/12/+*/' <<< "**_**_**_*_****_*"

Answer 3

स्वच्छ , 200 192 189 बाइट्स

import StdEnv,Text
f"_"=["_"]
f l=["("+a+p+b+")"\\p<-[l%(0,i)\\i<-[0..indexOf"_"l]|endsWith(l%(0,i))l],t<-[tl(init(split p l))],n<-indexList t,a<-f(join p(take n t))&b<-f(join p(drop n t))]

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

फ़ंक्शन को परिभाषित करता है f, ले रहा है String, और [String]अंदर परिणाम के साथ एक सिंगलटन लौटा रहा है ।

कुछ साफ सामान:

• रेगेक्स का उपयोग नहीं करता है
• सिवाय ऑपरेटरों के लिए किसी भी चरित्र के साथ काम करता है_

Answer 4

रेटिना 0.8.2 , 138 बाइट्स

.+
($&)
+`\((\d+)(_|((?<i>(?<i>\d+))|_(?<-i>\k<i>)+)+(?(i)(?!)))\1(_|((?<i>(?<i>\d+))|_(?<-i>\k<i>)+)+(?(i)(?!)))\1\)
(($2)$1($4))
\(_\)
_

इसे ऑनलाइन आज़माएं! लिंक में तेज परीक्षण मामले शामिल हैं। स्पष्टीकरण: रेगेक्स इंजन स्ट्रिंग में विभाजित करने के लिए बैकट्रैकिंग का उपयोग करता है जो तब iसंतुलन समूह से धकेल दिया जाता है या पॉपअप किया जाता है । पहले चर से पहले शुरू में हमेशा कम से कम एक ऑपरेटर को धक्का देने की एक रन है। एक चर के बाद, कम से कम एक ऑपरेटर पॉप होता है, जिस बिंदु पर या तो एक धक्का दिया गया ऑपरेटर चलता है या दूसरा चर कानूनी होता है। ऑपरेटरों को डुप्लिकेट में समूह में धकेल दिया जाता है ताकि उन्हें सही तरीके से पॉप किया जा सके। उदाहरण:

Input           Stack
Push *          * *
Push *++*+***   * * *++*+*** *++*+***
Push +          * * *++*+*** *++*+*** + +
Push +          * * *++*+*** *++*+*** + + + +
Variable _
Pop +           * * *++*+*** *++*+*** + + +
Variable _
Pop +           * * *++*+*** *++*+*** + +
Pop +           * * *++*+*** *++*+*** +
Variable _
Pop +           * * *++*+*** *++*+***
Pop *++*+***    * * *++*+***
Variable _
Pop *++*+***    * *
Pop *           *
Push *          * * *
Variable _
Pop *           * *
Push *          * * * *
Variable _
Pop *           * * *
Variable _
Pop *           * *
Pop *           *
Pop *

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

Comments

इसके लिए भी विफल रहता है **_**_**_*_****_*।

— user202729

@ user202729 अब काम कर रहा है?

— नील

@ नील यह अब काम कर रहा है, हाँ।

— Οurous

Answer 5

हास्केल , 167 166 बाइट्स

head.e
e('_':r)=["_",r]
e(x:r)=[x]%r
e _=[]
o%t@(c:r)|[x,u]<-e t,n<-length o,[y,v]<-e$drop n u,all((==o).take n)[u,v]=['(':x++o++y++")",drop n v]|p<-o++[c]=p%r
o%_=[]

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: head.e "**_**_**_*_****_*"पैदावार ((_*(_*(_*_)))*_)। सिवाय सभी पात्रों को _ऑपरेटरों के रूप में व्याख्या की जाती है, _अपने आप में एक पहचानकर्ता को दर्शाता है।

Answer 6

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

from re import*
P=r'([*+]+)'+r'(\(.+?\)|_)\1'*2;R=lambda i,J=lambda i,o:i[:o]+sub(P,lambda o:'('+o[2]+o[1]+o[3]+')',i[o:],1),s=search:s(P,i)and R([J(i,o)for o in range(len(i))if s(P,J(i,o))or J(i,o)[0]+J(i,o)[-1]=='()'][0])or i

नाम के एक अनाम फ़ंक्शन को परिभाषित करता है R।

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

Comments

ध्यान दें कि आप इसके अलावा किसी भी वर्ण का उपयोग कर सकते हैं _*+; जो उदाहरण में इस्तेमाल किए गए थे। आप इसे अपने रेगीक्स को गोल्फ में इस्तेमाल करने में सक्षम हो सकते हैं (जैसे \dइसके बजाय उपयोग करके [*+])।

— फल