Anyfix संकेतन लागू करें!

16

उपसर्ग संकेतन में, ऑपरेटर तर्क से पहले आता है, इसलिए आप कल्पना कर सकते हैं कि ऑपरेटर कॉल next()करता है जिसे पुनरावर्ती कहा जाता है। Infix संकेतन में, ऑपरेटर तर्कों के बीच जाता है, इसलिए आप इसे केवल एक पेड़ के रूप में कल्पना कर सकते हैं। उपसर्ग संकेतन में, ऑपरेटर तर्क के बाद आता है, इसलिए आप इसे स्टैक-आधारित के रूप में कल्पना कर सकते हैं।

किसी भी उपप्रकार संकेतन में, ऑपरेटर कहीं भी जा सकता है * । यदि कोई ऑपरेटर दिखाता है और पर्याप्त तर्क नहीं हैं, तो ऑपरेटर तब तक इंतजार करता है जब तक कि पर्याप्त तर्क न हों। इस चुनौती के लिए, आपको एक बहुत ही मूल उपसर्ग मूल्यांकनकर्ता को लागू करना है। (ध्यान दें कि कोई भी उपसर्ग एक मनोरंजक भाषा है जिसे मैंने त्याग दिया है कि आप यहाँ के साथ खेल सकते हैं या यहाँ देख सकते हैं )

आपको निम्न आदेशों का समर्थन करने की आवश्यकता होगी:

(एरिटी 1)

  • डुप्लिकेट
  • नकारात्मक

(एरिटी 2)

  • इसके अलावा
  • गुणन
  • समानता: रिटर्न 0या 1।

आप इन आदेशों के लिए किसी भी पांच गैर-व्हाट्सएप प्रतीकों का उपयोग करना चुन सकते हैं। प्रदर्शनकारी उद्देश्यों के लिए, मैं "डुप्लिकेट के ×रूप में, गुणन के +रूप में और इसके अतिरिक्त का उपयोग करूंगा ।

शाब्दिक के लिए, आपको केवल गैर-नकारात्मक पूर्णांक का समर्थन करने की आवश्यकता है, लेकिन आपके दुभाषिया को सभी पूर्णांकों (आपकी भाषा के भीतर (उचित) पूर्णांक सीमा) में समाहित करने में सक्षम होना चाहिए।

एक उदाहरण पर एक नज़र लेते हैं: 10+5। भंडारण को एक स्टैक के रूप में व्यवहार करना चाहिए, न कि एक कतार के रूप में। तो पहले, स्टैक पर शुरू होता है [], और कतार ऑपरेटर की सूची शुरू होती है []। फिर, शाब्दिक 10मूल्यांकन किया जाता है जो स्टैक बनाता है [10]। इसके बाद, ऑपरेटर +का मूल्यांकन किया जाता है, जिसे दो तर्कों की आवश्यकता होती है। हालाँकि, स्टैक पर केवल एक तर्क है, इसलिए कतारबद्ध ऑपरेटर सूची बन जाती है ['+']। फिर, शाब्दिक 5मूल्यांकन किया जाता है जो स्टैक बनाता है [10, 5]। इस बिंदु पर, ऑपरेटर '+'का मूल्यांकन किया जा सकता है, इसलिए यह स्टैक [15]और कतार बना रहा है []।

अंतिम परिणाम होना चाहिए [15]के लिए + 10 5, 10 + 5, और 10 5 +।

चलो एक कठिन उदाहरण पर एक नज़र लेते हैं: 10+"। स्टैक और कतार के रूप में []और शुरू करते हैं []। 10पहले मूल्यांकन किया जाता है जो स्टैक बनाता है [10]। अगला, +मूल्यांकन किया जाता है, जो स्टैक को नहीं बदलता है (क्योंकि पर्याप्त तर्क नहीं हैं) और कतार बनाता है ['+']। फिर, "मूल्यांकन किया जाता है। यह तुरंत चल सकता है इसलिए यह स्टैक बना रहा है [10, 10]। +अब मूल्यांकन किया जा सकता है ताकि ढेर [20]और कतार बन जाए []। अंतिम परिणाम है [20]।

संचालन के आदेश के बारे में क्या?

आइए एक नजर डालते हैं ×+"10 10। स्टैक और कतार दोनों के रूप में शुरू []:

  • ×: ढेर अपरिवर्तित है और कतार बन जाती है ['×']।
  • +: ढेर अपरिवर्तित है और कतार बन जाती है ['×', '+']।
  • ": ढेर अपरिवर्तित है और कतार बन जाती है ['×', '+', '"']।
  • 10: स्टैक बन जाता है [10]। भले ही ×पहले ऑपरेटर का मूल्यांकन किया जाना चाहिए क्योंकि यह पहले दिखाई देता है, "तुरंत चल सकता है और इससे पहले कि कोई भी ऑपरेटर नहीं चला सकता है, इसलिए इसका मूल्यांकन किया जाता है। ढेर बन जाता है [10, 10]और कतार ['×', '+']। ×अब मूल्यांकन किया जा सकता है, जो स्टैक [100]और कतार बनाता है ['+']।
  • 10: स्टैक बन जाता है [100, 10], जो +मूल्यांकन करने की अनुमति देता है। ढेर बन जाता है [110]और कतार []।

अंतिम परिणाम है [110]।

इन प्रदर्शनों में उपयोग की जाने वाली आज्ञाएँ उपसर्ग भाषा के अनुरूप हैं; हालाँकि, अंतिम उदाहरण मेरे दुभाषिया में बग के कारण काम नहीं करेगा। (डिस्क्लेमर: आपके सबमिशन का उपयोग किसी भी उपप्रकार दुभाषिया में नहीं किया जाएगा)

चुनौती

5 गैर-व्हॉट्सएप गैर-अंक वर्णों के एक सेट का चयन करें और ऊपर दिए गए विनिर्देशों के अनुसार एक उपसर्ग दुभाषिया बनाएं। आपका कार्यक्रम या तो एकवचन सरणी या इसके द्वारा निहित मूल्य को आउटपुट कर सकता है; यह गारंटी दी जाती है कि निष्पादन के अंत में मूल्यों के ढेर में केवल एक मूल्य होगा और निष्पादन के अंत में ऑपरेटरों की कतार खाली हो जाएगी।

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

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

इन परीक्षण मामलों के लिए, डुप्लिकेट है ", नकारात्मक है -, इसके अलावा +, गुणन है ×, और समानता है =।

Input -> Output
1+2×3 -> 9
1"+"+ -> 4
2"××" -> 16
3"×+" -> 18
3"+×" -> 36
123"= -> 1 ("= always gives 1)
1+2=3 -> 1
1"=2+ -> 3
1-2-+ -> -3
-1-2+ -> 3 (hehe, the `-1` becomes `+1` at the `-` rather than making the `2` a `-1`)
+×"10 10 -> 200 (after the 10 is duplicated (duplication is delayed), 10 + 10 is performed and then 20 * 10, giving 200)

नियम

  • स्टैंडर्ड लोफॉल्स लागू होते हैं
  • यदि आप चाहें तो आप किसी भी उपप्रकार के आधिकारिक दुभाषिया को ले सकते हैं और उसे गोल्फ में डाल सकते हैं। बुरी तरह से हारने की उम्मीद है।

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

* वास्तव में ऐसा नहीं है

code-golf  string  interpreter 
— HyperNeutrino
स्रोत
2
कहीं भी जाओ * ™।
— जोनाथन एलन
समानता ऑपरेटर का परिणाम क्या है? 0और 1?
— फेलिक्स पालमेन
1
@JonathanAllan ऊपर देखें; मैंने
— HyperNeutrino
1
@ रिक्शेकॉक ज़रूर।
— हाइपरन्यूट्रिनो
1
आपको शायद ×+"10 10परीक्षण के मामलों में शामिल होना चाहिए , या व्हॉट्सएप का उपयोग करते हुए कोई अन्य उदाहरण 1) और 2) डुप्लिकेट ऑपरेटर के उपयोग में देरी (दो चीजें जो मुझे पूरी तरह से याद थीं)।
— अरनुलद

जवाबों:

5

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

एक पूर्णांक देता है।

e=>e.replace(/\d+|\S/g,v=>{for((1/v?s:v>','?u:b)[U='unshift'](v);!!u[0]/s[0]?s[U](u.pop()>'c'?s[0]:-S()):!!b[0]/s[1]?s[U](+eval(S(o=b.pop())+(o<'$'?'==':o)+S())):0;);},s=[],u=[],b=[],S=_=>s.shift())|s

उपयोग किए गए वर्ण:

  • +इसके अलावा
  • *: गुणन
  • #: समानता
  • d: डुप्लिकेट
  • -: नकारात्मक

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

कोड स्निपेट दिखाएं

प्रारूपित और टिप्पणी की गई

e => e.replace(                     // given an expression e, for each value v matching
  /\d+|\S/g, v => {                 // a group of digits or any other non-whitespace char.
    for(                            //   this loop processes as many operators as possible
      (                             //   insert v at the beginning of the relevant stack:
        1 / v ? s : v > ',' ? u : b //     either value, unary operator or binary operator
      )[U = 'unshift'](v);          //     (s[], u[] or b[] respectively)
      !!u[0] / s[0] ?               //   if there's at least 1 value and 1 unary operator:
        s[U](                       //     unshift into s[]:
          u.pop() > 'c' ?           //       for the duplicate operator:
            s[0]                    //         a copy of the last value
          :                         //       else, for the negative operator:
            -S()                    //         the opposite of the last value
        ) :                         //     end of unshift()
      !!b[0] / s[1] ?               //   if there's at least 2 values and 1 binary operator:
        s[U](                       //     unshift into s[]:
          +eval(                    //       the result of the following expression:
            S(o = b.pop()) +        //         the last value, followed by the
            (o < '$' ? '==' : o) +  //         binary operator o with '#' replaced by '=='
            S()                     //         followed by the penultimate value
          )                         //       end of eval()
        ) : 0;                      //     end of unshift()
    );                              //   end of for()
  },                                // end of replace() callback
  s = [],                           // initialize the value stack s[]
  u = [],                           // initialize the unary operator stack u[]
  b = [],                           // initialize the binary operator stack b[]
  S = _ => s.shift()                // S = helper function to shift from s[]
) | s                               // return the final result
— Arnauld
स्रोत
इस काम के लिए मत सोचो -1+-2। -3 के बजाय 3 लौटाता है।
— रिक हिचकॉक 14
1
@ रिकहचॉक मेरी समझ यह है कि 2 -को -1तुरंत लागू किया जाना चाहिए ।
— अरनुलद
मुझे लगता है कि होगा 2 -के साथ जाना होगा 2, क्योंकि यह आता है के बाद एक और ऑपरेटर। शायद @HyperNeutrino स्पष्ट कर सकता है। नकारात्मक ऑपरेटर कुछ स्थितियों में अस्पष्ट हो सकता है।
— रिक हिचकॉक
3

जावास्क्रिप्ट (ईएस 6), 162 152 143 150 बाइट्स

(s,N=s.replace(/(-?\d+)-|-(-)/g,'- $1 ').match(/(- ?)*?\d+|R/g))=>+eval(`R=${N[0]>'9'?N[1]:N[0]},${s.match(/[+*=]/g).map((o,i)=>'R=R'+o+'='+N[i+1])}`)

थोड़ा अपराजित:

(s,
 N=s.replace(/(-?\d+)-|-(-)/g,'- $1 ').      //change postfix negatives to prefix,
                                             //and change "--" to "- - "
     match(/(- ?)*?\d+|R/g)                  //grab numbers and duplicates
)=>+eval(`R=${N[0] > '9' ?  N[1] : N[0]},    //handle a delayed duplicate
          ${s.match(/[+*=]/g).               //grab the operators
              map((o,i)=>'R=R'+o+'='+N[i+1]) //create a comma-separated list of assignments
           }
         `)

व्याख्या

मैं *गुणा और Rडुप्लिकेट के लिए उपयोग कर रहा हूँ । अन्य ऑपरेटर प्रश्न में समान हैं।

N संख्याओं की सरणी बन जाती है (डुप्लिकेट सहित)।

replaceइस मामले में जहां ऋणात्मक चिह्न आता है संभालती के बाद नंबर। उदाहरण के लिए, यह बदल जाएगा 1-करने के लिए - 1और -1-करने के लिए - -1।

के भीतर eval, s.matchबाइनरी ऑपरेटरों की सरणी बनाता है। ध्यान दें कि इसमें हमेशा एक से कम तत्व होंगे N।

फ़ंक्शन का परिणाम evalसंख्याओं और ऑपरेटरों के मानचित्रण का है।

यहाँ evalपरीक्षण मामलों में से प्रत्येक के लिए एड है:

0+2*3        R=0,R=R+=2,R=R*=3        = 6 
1+2*3        R=1,R=R+=2,R=R*=3        = 9 
1R+R+        R=1,R=R+=R,R=R+=R        = 4 
2R**R        R=2,R=R*=R,R=R*=R        = 16 
3R*+R        R=3,R=R*=R,R=R+=R        = 18 
3R+*R        R=3,R=R+=R,R=R*=R        = 36 
123R=        R=123,R=R==R             = 1 
1+2=3        R=1,R=R+=2,R=R==3        = 1 
1R=2+        R=1,R=R==R,R=R+=2        = 3 
1-2-+        R=- 1,R=R+=- 2           = -3 
-1-2+        R=1,R=R+=2               = 3 
*+R10 10     R=10,R=R*=10,R=R+=10     = 110 
+*R10 10     R=10,R=R+=10,R=R*=10     = 200 
-1+--2       R=-1,R=R+=- -2           = 1 
-1+-2        R=-1,R=R+=-2             = -3

जावास्क्रिप्ट अभिव्यक्ति में अल्पविराम ऑपरेटर अपनी अंतिम अभिव्यक्ति का परिणाम देता है, इसलिए mapस्वचालित रूप से एक प्रयोग करने योग्य अभिव्यक्ति देता है।

+प्रवेश से पहले की जरूरत है evalबदलने के लिए trueकरने के लिए 1और falseकरने के लिए 0।

Rदोनों चर और डुप्लिकेट ऑपरेटर के रूप में उपयोग करने से mapउप-अभिव्यक्तियों को सरल बनाता है ।

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

कोड स्निपेट दिखाएं

— रिक हिचकॉक
स्रोत
2
मुझे नहीं लगता कि replaceकाम करता है। यह रिटर्न 3के लिए -1+--2और मुझे लगता है कि 1सही (होगा 1परिवर्तन तीन बार पर हस्ताक्षर के लिए एक दूसरा तर्क है से पहले +, जिसका परिणाम उपलब्ध -1 + 2)।
— फेलिक्स पालमेन
शानदार कैच, @FelixPalmen। अब तय हो गया।
— रिक हिचकॉक 14
2

जावास्क्रिप्ट, 321 311 बाइट्स

_="f=a=>(a.replace(/\\d+|./g,mq!~(b='+*=\"- '.indexOf(a))|b>2j3j4j5&&o+aw1/y?(y*=-1wcz:1/y?oywcz:hz,rql.map(z=>m(lki,1)[0],i)),hq1/s[1]?sk0,2,+eval(`y${a=='='?a+a:a}s[1]`)):cz,cqlki,0,a),s=[],l=[],e='splice'),s)z(a,i)ys[0]w)^r``:q=z=>os.unshift(k[e](j?b-";for(i of"jkoqwyz")with(_.split(i))_=join(pop());eval(_)

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

प्रश्न में पाँच वर्ण समान हैं, सिवाय *गुणा के। RegPack
का उपयोग करके स्क्रिप्ट को संपीड़ित किया जाता है । मूल स्क्रिप्ट को _मूल्यांकन के बाद चर में संग्रहीत किया जाता है ।

इस काम के लिए मत सोचो -1+-2। -3 के बजाय 3 लौटाता है।
— रिक हिचकॉक 14
@RickHitchcock। आप यह क्यों मानते हैं कि इसके -3बजाय लौटना चाहिए 3?
मैं नकारात्मक ऑपरेटर को गलत समझ सकता हूं। आम तौर पर, -1 + -2है -3, लेकिन क्या इसके --1 + 2बजाय इसे पार्स किया जाना चाहिए ?
— रिक हिचकॉक
1
@RickHitchcock। मुझे पूरा यकीन है कि परिणाम है 3। 2स्टैक पर आने से पहले , दूसरे -का मूल्यांकन किया जाता है, और इसलिए हमारे पास 1 2 +वास्तव में ऐसा है 3। आह, और शायद आपको अपना उत्तर भी संपादित करना होगा।
शायद तुम सही हो। आपको और अर्नुलद को एक ही उत्तर मिलता है, और मैंने ओपी से स्पष्टीकरण मांगा है। अगर मैं कर सकता था तो आप फिर से मतदान करेंगे।
— रिक हिचकॉक
1

हास्केल , 251 बाइट्स

(#([],[]))
(x:r)#(o,n)|x>'9'=r#h(o++[x],n)|[(a,t)]<-lex$x:r=t#h(o,read a:n)
_#(o,n:_)=n
h=e.e
e(o:s,n:m:r)|o>'N'=e(s,g[o]n m:r)
e(o:s,n:r)|o=='D'=e(s,n:n:r)|o=='N'=e(s,-n:r)
e(o:s,n)|(p,m)<-e(s,n)=(o:p,m)
e t=t
g"a"=(+)
g"m"=(*)
g"q"=(((0^).abs).).(-)

इसे ऑनलाइन आज़माएं! निम्न वर्णों का उपयोग करता है: aइसके अलावा, mगुणन के लिए, qसमानता के लिए, Dडुप्लिकेट के लिए और Nनकार के लिए। (मैं eसमानता के लिए उपयोग करना चाहता था , लेकिन इस समस्या में भाग गया कि एक संख्या के रूप में lexपर्स 2e3।) उदाहरण उपयोग: (#([],[])) "2a3 4m"पैदावार 20।

— Laikoni
स्रोत
1

6502 मशीन कोड (C64), 697 बाइट्स

00 C0 A2 00 86 29 86 26 86 27 86 28 86 4B 86 4C 86 CC 20 E4 FF F0 FB C9 0D F0
10 C9 20 30 F3 A6 27 9D B7 C2 20 D2 FF E6 27 D0 E7 C6 CC A9 20 20 1C EA A9 0D
20 D2 FF 20 95 C0 20 09 C1 20 95 C0 A6 26 E4 27 F0 4E BD B7 C2 E6 26 C9 20 F0
E8 C9 2D D0 09 A6 4C A9 01 9D B7 C3 D0 32 C9 22 D0 09 A6 4C A9 02 9D B7 C3 D0
25 C9 2B D0 09 A6 4C A9 81 9D B7 C3 D0 18 C9 2A D0 09 A6 4C A9 82 9D B7 C3 D0
0B C9 3D D0 0D A6 4C A9 83 9D B7 C3 E6 28 E6 4C D0 A3 4C 8A C2 A6 29 F0 6F A4
28 F0 6B CA F0 4B C6 28 A6 4B E6 4B BD B7 C3 F0 F5 30 14 AA CA D0 0B 20 7B C2
20 E1 C1 20 4D C2 D0 D9 20 5C C2 D0 D4 29 0F AA CA D0 0B 20 6D C2 20 08 C2 20
4D C2 D0 C3 CA D0 0B 20 6D C2 20 16 C2 20 4D C2 D0 B5 20 6D C2 20 F4 C1 20 4D
C2 D0 AA A4 4B B9 B7 C3 F0 02 10 AC C8 C4 4C F0 0F B9 B7 C3 F0 F6 30 F4 AA A9
00 99 B7 C3 F0 A6 60 A0 00 A6 26 E4 27 F0 15 BD B7 C2 C9 30 30 0E C9 3A 10 0A
E6 26 99 37 C4 C8 C0 05 D0 E5 C0 00 F0 08 A9 00 99 37 C4 20 39 C2 60 A2 FF E8
BD 37 C4 D0 FA A0 06 88 CA 30 0A BD 37 C4 29 0F 99 37 C4 10 F2 A9 00 99 37 C4
88 10 F8 A9 00 8D 3D C4 8D 3E C4 A2 10 A0 7B 18 B9 BD C3 90 02 09 10 4A 99 BD
C3 C8 10 F2 6E 3E C4 6E 3D C4 CA D0 01 60 A0 04 B9 38 C4 C9 08 30 05 E9 03 99
38 C4 88 10 F1 30 D2 A2 06 A9 00 9D 36 C4 CA D0 FA A2 10 A0 04 B9 38 C4 C9 05
30 05 69 02 99 38 C4 88 10 F1 A0 04 0E 3D C4 2E 3E C4 B9 38 C4 2A C9 10 29 0F
99 38 C4 88 10 F2 CA D0 D6 C0 05 F0 06 C8 B9 37 C4 F0 F6 09 30 9D 37 C4 E8 C8
C0 06 F0 05 B9 37 C4 90 F0 A9 00 9D 37 C4 60 A9 FF 45 FC 85 9F A9 FF 45 FB 85
9E E6 9E D0 02 E6 9F 60 A2 00 86 9F A5 FB C5 FD D0 07 A5 FC C5 FE D0 01 E8 86
9E 60 A5 FB 18 65 FD 85 9E A5 FC 65 FE 85 9F 60 A9 00 85 9E 85 9F A2 10 46 FC
66 FB 90 0D A5 FD 18 65 9E 85 9E A5 FE 65 9F 85 9F 06 FD 26 FE CA 10 E6 60 20
33 C1 A6 29 AD 3D C4 9D 3F C4 AD 3E C4 9D 3F C5 E6 29 60 A6 29 A5 9E 9D 3F C4
A5 9F 9D 3F C5 E6 29 60 A6 29 BD 3E C4 9D 3F C4 BD 3E C5 9D 3F C5 E6 29 60 C6
29 A6 29 BD 3F C4 85 FD BD 3F C5 85 FE C6 29 A6 29 BD 3F C4 85 FB BD 3F C5 85
FC 60 A6 29 BD 3E C5 10 13 20 7B C2 20 E1 C1 20 4D C2 A9 2D 20 D2 FF A6 29 BD
3E C5 8D 3E C4 BD 3E C4 8D 3D C4 20 8B C1 A9 37 A0 C4 4C 1E AB

ऑनलाइन डेमो

उपयोग करें sys49152 , फिर किसी भी उपसर्ग की अभिव्यक्ति दर्ज करें और रिटर्न दबाएं।

  • कोई त्रुटि जाँच के करीब नहीं है, इसलिए अमान्य अभिव्यक्तियों पर मज़ेदार आउटपुट की अपेक्षा करें।
  • गुणन के लिए प्रतीक है *, अन्य सभी जैसा कि सुझाव दिया गया है।
  • अधिकतम इनपुट लंबाई 256 वर्ण है, 127 से अधिक ऑपरेटरों की कतार नहीं हो सकती।
  • इनपुट दिनचर्या नियंत्रण पात्रों को संभालती नहीं है , इसलिए गलत नहीं है;)
  • पूर्णांक 16 बिट पर हस्ताक्षर किए गए हैं, अतिप्रवाह चुपचाप चारों ओर लपेटेंगे।
  • बाइट की गिनती थोड़ी बड़ी है क्योंकि यह सीपीयू गुणन भी नहीं जानता है और C64 OS / ROM आपको नहीं देता है दशमलव स्ट्रिंग्स से / के लिए कोई पूर्णांक अंकगणितीय या रूपांतरण ।

यहाँ पठनीय ca65- स्टाइल असेंबलर सोर्स कोड है ।

— फेलिक्स पालमेन
स्रोत
1

VB.NET (.NET 4.5) 615 576 बाइट्स

-39 बाइट्स बदलकर फेलिक्स पालमेन के लिए धन्यवाद \r\n करने के लिए\n

आवश्यकता Imports System.Collections.Generic(बाइट गिनती में शामिल)

Dim s=New Stack(Of Long),q=New List(Of String),i=Nothing,t=0,c=0
Function A(n)
For Each c In n
If Long.TryParse(c,t)Then
i=i &"0"+t
Else
If c<>" "Then q.Add(c)
If i<>A Then s.Push(i)
i=A
End If
If i=A Then E
Next
If i<>A Then s.Push(i)
E
A=s
End Function
Sub E()
c=s.Count
If c=0Then Exit Sub
For Each op In q
If op="-"Or op="d"Or c>1Then
Select Case op
Case"*"
s.Push(s.Pop*s.Pop)
Case"+"
s.Push(s.Pop+s.Pop)
Case"="
s.Push(-(s.Pop=s.Pop))
Case"-"
s.Push(-s.Pop)
Case"d"
s.Push(s.Peek)
End Select
q.Remove(op)
E
Exit Sub
End If
Next
End Sub

प्रविष्टि बिंदु फ़ंक्शन है A , जो इनपुट के रूप में एक स्ट्रिंग लेता है और वापस लौटता है Stack(Of Long)।

प्रतीक:

  • जोड़ - +
  • गुणा - *
  • समानता - =
  • निषेध - -
  • दोहराव - d

अवलोकन:

फंक्शन Aइनपुट लेता है और इसे टोकन देता है। यह Long?बहु-अंकों वाले पूर्णांकों के लिए एक रनिंग टोटल का उपयोग करता है , जो Nothingयह दर्शाता है कि हम वर्तमान में पूर्णांक नहीं पढ़ रहे हैं।

सबरूटीन Eपूर्णांकों और ऑपरेटरों के लिए कतार के ढेर लग जाते हैं, और anyfix अंकन मूल्यांकन करता है। यह अपने आप को पुनरावर्ती कहता है जब तक कि कोई क्रिया शेष न हो।

मैं घोषणा और पैरामीटर दोनों को पारित करने पर बाइट्स को बचाने के लिए वैश्विक पैरामेट्स की घोषणा करता हूं।

से रिटर्न वैल्यू Aमैचिंग वैरिएबल के लिए मान निर्दिष्ट करके सेट की गई है A।

वीबी Trueके बराबर है -1, ताकि ऑपरेशन को सही मूल्य प्राप्त करने के लिए परिणाम को नकारना पड़े।

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

— ब्रायन जे
स्रोत
— फेलिक्स पालमेन
btw, के साथ Imports, मैं केवल एक बाइट गिनती मिलता है 576- क्या आप गर्भपात हो सकता है?
— फेलिक्स पालमेन
@FelixPalmen की \r\nबजाय मैंने गणना की \n, ताकि जहां विसंगति हो।
— ब्रायन जे।
@FelixPalmen जोड़ा TIO, मुझे याद दिलाने के लिए धन्यवाद! :) (ओह, मुझे एहसास नहीं था कि आपने इस पोस्ट के लिए इसे पहले ही बना लिया है)
— ब्रायन जे
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.