एक अभिव्यक्ति को पानिक्स संकेतन में बदलें

Question

मैं esolangs ब्राउज़ कर रहा था, और इस भाषा पर विचार कर रहा था: https://github.com/catseye/Quylthulg ।

इस भाषा के बारे में एक दिलचस्प बात यह है कि यह उपसर्ग, पोस्टफिक्स या इन्फिक्स का उपयोग नहीं करता है, यह इन तीनों का उपयोग करता है , इसे "पैनिफ़िक्स" संकेतन कहते हैं।

यहाँ एक उदाहरण है। 1+2पैनिफ़िक्स में सामान्य इन्फिक्स का प्रतिनिधित्व करने के लिए , यह हो जाता है +1+2+:। नोटिस करें कि ऑपरेटर पहले, बीच में और ऑपरेंड के बाद दोनों कैसे है। एक और उदाहरण है (1+2)*3। यह बन जाता है *+1+2+*3*। सूचना फिर से कैसे *ऑपरेंड के संबंध में सभी तीन स्थानों में है +1+2+और 3।

चुनौती

जैसा कि आप अनुमान लगा सकते हैं, इस चुनौती में आपका काम एक अभिव्यक्ति को इन्फिक्स से पैनफिक्स में बदलना है।

कुछ स्पष्टीकरण:

• आपको केवल चार बुनियादी कार्यों से निपटना होगा: +-*/
• आपको उन बाइनरी के संस्करणों के साथ सौदा नहीं करना पड़ेगा, केवल बाइनरी
• आपको कोष्ठक से निपटना होगा
• उन सभी के लिए */तब +-और बाईं सहानुभूति के सामान्य पूर्वता नियमों को मान लें ।
• संख्या गैर-पूर्णांक होगी
• आप वैकल्पिक रूप से इनपुट और आउटपुट दोनों में रिक्त स्थान रख सकते हैं

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

1+2  ->  +1+2+
1+2+3  ->  ++1+2++3+
(1+2)*3  ->  *+1+2+*3*
10/2*5  ->  */10/2/*5*
(5+3)*((9+18)/4-1)  ->  *+5+3+*-/+9+18+/4/-1-*

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है !

Answer 1

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

f=(s,t=s.replace(/[*-/]/g,"'$&'"),u=t.replace(/^(.*?)([*-9]+)'([*/])'([*-9]+)|([*-9]+)'([+-])'([*-9]+)|\(([*-9]+)\)/,"$1$3$2$3$4$3$6$5$6$7$6$8"))=>t==u?t:f(s,u)

सभी ऑपरेटरों को उद्धृत करके काम करता है (जो उन्हें पहले वर्ण कोड देता है *), फिर उपलब्ध '*'या '/'संचालन, '+'या '-'संचालन या ()एस की तलाश में है, और पहले को इसके पैनीफिक्स नोटेशन के साथ बदल रहा है। उदाहरण:

(5+3)*((9+18)/4-1)
(5'+'3)'*'((9'+'18)'/'4'-'1)
(+5+3+)'*'((9'+'18)'/'4'-'1)
+5+3+'*'((9'+'18)'/'4'-'1)
+5+3+'*'((+9+18+)'/'4'-'1)
+5+3+'*'(+9+18+'/'4'-'1)
+5+3+'*'(/+9+18+/4/'-'1)
+5+3+'*'(-/+9+18+/4/-1-)
+5+3+'*'-/+9+18+/4/-1-
*+5+3+*-/+9+18+/4/-1-*

Answer 2

जावास्क्रिप्ट (ईएस 6), ^{_{285 282 281 267 251 243 241 238 234 232}} 231 बाइट्स

~ 15 बाइट्स नील को धन्यवाद ।

f=(I,E=I.match(/\d+|./g),i=0)=>(J=T=>T.map?T.map(J).join``:T)((R=(H,l=(P=_=>(t=E[i++])<")"?R(0):t)(),C,F)=>{for(;(C=P())>")"&&(q=C>"*"&&C<"/")*H-1;)F=q+H?l=[C,l,C,P(),C]:F?l[3]=[C,l[3],C,R(1),C]:l=R(1,l,i--)
i-=C>")"
return l})(0))

जावास्क्रिप्ट में यह गणितज्ञ की तुलना में थोड़ा कठिन है। यह मूल रूप से एक अति-विशिष्ट और गोल्फ ऑपरेटर-पूर्वता पार्सर है ।

अमान्य इनपुट्स के कारण ओवरफ्लो हो जाता है।

डेमो

f=(I,E=I.match(/\d+|./g),i=0)=>(J=T=>T.map?T.map(J).join``:T)((R=(H,l=(P=_=>(t=E[i++])<")"?R(0):t)(),C,F)=>{for(;(C=P())>")"&&(q=C>"*"&&C<"/")*H-1;)F=q+H?l=[C,l,C,P(),C]:F?l[3]=[C,l[3],C,R(1),C]:l=R(1,l,i--)
i-=C>")"
return l})(0))

<input id="input" value="(5+3)*((9+18)/4-1)"/><button onclick="console.log(f(document.querySelector('#input').value))">Convert</button>

Ungolfed

convert = input => {
  tokens = input.match(/\d+|./g);
  i = 0;
  parse_token = () => (token = tokens[i++]) == "(" ? parse_tree(false) : token;
  parse_tree = (mul_div_mode, left = parse_token()) => {
    while ((oper = parse_token()) != ")" && !((is_plus_minus = oper == "+" || oper == "-") && mul_div_mode)) {
      if (is_plus_minus || mul_div_mode)
        left = [oper, left, oper, parse_token(), oper];
      else if (non_first)
        left[3] = [oper, left[3], oper, parse_tree(true), oper];
      else
        left = parse_tree(true, left, i--);
      non_first = true;
    }
    if (oper != ")")
      i--;
    return left;
  };
  format_tree = tree => tree.map ? tree.map(format_tree).join("") : tree;
  return format_tree(parse_tree(false));
}

Comments

S.split``यह होना चाहिए [...S], हालांकि यह वास्तव में /\d+|./gअप-फ्रंट पर मेल करने और इसके बजाय उस पर काम करने में मदद कर सकता है ।

— नील

@ नील धन्यवाद। मैं उस पर गौर करूंगा।

— पुरकाकूदरी

Answer 3

मेथेमेटिका, 203 195 बाइट्स

यह कुशल से कम होने की संभावना है, लेकिन लगता है कि यह काम करेगा।

Function[f,ReleaseHold[(Inactivate@f/._[Plus][a_,b_/;b<0]:>a~"-"~-b//Activate@*Hold)//.a_/b_:>a~"/"~b/.{a_Integer:>ToString@a,Plus:>"+",Times:>"*"}]//.a_String~b_~c_String:>b<>a<>b<>c<>b,HoldAll]

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

स्पष्टीकरण: यह पूरी अभिव्यक्ति को एक पेड़ के रूप में व्याख्या करने के लिए काफी आसान है, जैसे:

इस स्तर पर ऑपरेटर (प्रत्येक नोड जो पत्ती नहीं है) ऑपरेटर नहीं हैं, वे वास्तव में इस तरह के तार में परिवर्तित हो गए हैं "+"। पूर्णांक भी तार के लिए डाले जाते हैं। फिर एक दोहराया प्रतिस्थापन नियम हर नोड को परिवर्तित करता है जिसमें बिल्कुल दो लीफ्स होते हैं जो पैनिफ़िक्स में होता है parent-leaf1-parent-leaf2-parent। कुछ पुनरावृत्तियों के बाद पेड़ एक एकल स्ट्रिंग को कम कर देता है।

बाइट गिनती में मुख्य नुकसान यह है कि गणितज्ञ व्याख्या करता है

5 - 4 -> 5 + (-4)
9 / 3 -> 9 * (3^(-1))

और यह पार्सिंग समय पर भी होता है।

थोड़ा नीचे गिरा, क्योंकि पैटर्न a_/b_की भी व्याख्या की गई है a_ * (b_)^(-1)। इसके अलावा कुछ मामूली अनुकूलन कहीं और।

Answer 4

प्रोलॉग, 87 बाइट्स

x(T)-->{T=..[O,A,B]}->[O],x(A),[O],x(B),[O];[T].
p:-read(T),x(T,L,[]),maplist(write,L).

यह एक फ़ंक्शन है (ज्यादातर क्योंकि एक पूर्ण प्रोग्राम लिखने में प्रोलॉग में बॉयलरप्लेट के बुरे स्तर होते हैं; आम तौर पर, भले ही आप किसी प्रोग्राम को संकलित करते हैं, यह रन होने पर एक आरईपीएल पैदा करता है), कहा जाता है p। यह स्टड से इनपुट लेता है और स्टडआउट पर आउटपुट देता है। ध्यान दें कि आपको इनपुट में एक अवधि संलग्न करने की आवश्यकता है, जो उस तरह से एक दुर्भाग्यपूर्ण परिणाम है कि प्रोलॉग के इनपुट रूटीन काम करते हैं (वे इनपुट में अवधियों का उसी तरह से उपयोग करते हैं जिस तरह से अन्य भाषाएं नईलाइनों का उपयोग करती हैं); वह उत्तर को अयोग्य ठहरा सकता है या नहीं।

व्याख्या

प्रोलॉग में अंकगणित ऑपरेटरों को सामान्य रूप से टपल निर्माणकर्ता के रूप में व्याख्या की जाती है । हालाँकि, वे उसी पूर्ववर्ती नियमों का पालन करते हैं जैसा कि वे वास्तविक अंकगणितीय ऑपरेटरों पर आधारित हैं; आप बना सकते हैं tuples के साथ इन्फ़िक्स संकेतन, और +और -बाँध से भी कम समय कसकर *और /, साथ पूर्वता ले लिया एक समूह के भीतर सही करने के लिए छोड़ दिया है। यह वही है जो सवाल पूछता है; इस प्रकार, हम इनपुट से पूरे नेस्टेड टपल को पढ़ सकते हैं, और इसमें पहले से ही सही संरचना है। वही pकरता है।

अगला, हमें इसे पैनफिक्स नोटेशन में बदलने की आवश्यकता है। xनिर्माणकर्ता और पूर्णांकों का एक panfixed सूची में इनपुट बदल देता है, और एक अंग्रेजी वाक्य लगभग सीधे रूप में पढ़ा जा सकता है: " xकी Tहै: अगर Tनिर्माता के साथ एक टपल है Oऔर तर्क A, Bहै, तो O, xके A, O, xकी B, Oहै, और T"। अंत में, हमें बस सूची को बिना किसी विभाजक के प्रिंट करना होगा (अर्थात सूची के प्रत्येक तत्व पर maplistकॉल करने writeके लिए)।

मैंने इसका परीक्षण करने के लिए SWI-Prolog का उपयोग किया, क्योंकि ग्नू प्रोलॉग का मेरा संस्करण maplistअभी तक नहीं है (जाहिरा तौर पर इसे एक नए संस्करण में जोड़ा गया है), लेकिन यह आम तौर पर प्रोलॉग कार्यान्वयन के बीच काफी पोर्टेबल होना चाहिए।