सरल गोल्फ दुभाषिया

13

चुनौती:

आपका काम एक साधारण गोल्फिंग भाषा के लिए एक साधारण दुभाषिया बनाना है।

इनपुट:

इनपुट रिक्त स्थान द्वारा अलग किए गए स्ट्रिंग के रूप में होगा।

आप जो चाहें उससे अंतरिक्ष पृथक्करण को प्रतिस्थापित कर सकते हैं

आउटपुट:

सभी ऑपरेशन करने के बाद प्राप्त परिणाम (एक संख्या या एक स्ट्रिंग) को आउटपुट करें। यदि एक से अधिक आउटपुट हैं, तो एक साथ परिणाम (कोई विभाजक) नहीं दे सकते हैं। चर का प्रारंभिक मान हमेशा शून्य होता है। यानी: यह शुरू होता है0

भाषा सिंटैक्स:

भाषा के निम्नलिखित ऑपरेटर हैं:

inc  ---> add one to variable
dec  ---> remove one from variable
mult ---> multiply variable by 2
half ---> divide the variable by 2
Pri  ---> print the variable to console (or whatever your language has)
exit ---> end the program (anything after this is ignored)

उदाहरण:

inc inc inc dec Pri exit                 ---> 2
dec inc mult inc inc Pri                 ---> 2
inc inc inc mult half Pri exit inc       ---> 3
inc Pri inc Pri inc Pri exit half mult   ---> 123
Pri exit                                 ---> 0
inc half Pri exit                        ---> 0.5

प्रतिबंध:

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

ध्यान दें:

  • इनपुट हमेशा मान्य होगा। (अंतरिक्ष से अलग किए गए ऑपरेटरों के तार)
  • यदि आप दशमलव स्थान नहीं चाहते हैं, तो आप निकटतम पूर्णांक तक चक्कर लगा सकते हैं।
code-golf  math  interpreter 
— मुहम्मद सलमान
स्रोत
3
क्या मैं तार की सूची ले सकता हूं? क्या मैं दूसरे पूंजीकरण का उपयोग कर सकता हूं?
— user202729
एक्जिट केस जोड़ें? बाहर निकलना चाहिए
— l4m2
1
@ बाल्डो: आप नई लाइनों का उपयोग करके अलग हो सकते हैं
— मुहम्मद सलमान
3
हम्म, मैं उस भाषा को "गोल्फिंग भाषा" नहीं कहूंगा।
— पाओलो एबरमन
1
यह चौकोर और लंबे समय तक कमांड नामों के बजाय डबल और हाफ के साथ डेडफिश है
— जो किंग

जवाबों:

8

बैश , 61 बाइट्स

sed '1i0
s/.//2g;y"idmhe"+-*/q";/+\|-/i1
/*\|\//i2
/P/cdn'|dc

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

प्रोग्राम को dc प्रोग्राम में परिवर्तित करता है, फिर इसे dc कोड के रूप में मूल्यांकन करता है। यह इनपुट को न्यूलाइन्स द्वारा अलग किया गया है। ध्यान दें कि डीसी स्टैक-आधारित है और रिवर्स पॉलिश नोटेशन का उपयोग करता है।

इनपुट को पहले सेड पर लगाया जाता है

1i0 इनपुट की पहली पंक्ति पर, 0 डालें (प्रीपेन्ड), यह संचायक होगा

s/.//2g प्रत्येक लाइन पर पहला अक्षर लेकिन सब कुछ हटा दें

y"idmhe"+-*/q"क्रमशः idmheमें अनुवाद करें +-*/q, + - * / अंकगणित कमांड हैं और q प्रोग्राम को क्विट करता है

/+\|-/+ या - युक्त प्रत्येक पंक्ति में, i11 डालें

/*\|\//हर लाइन पर * या /, i2एक 2 डालें

/P/पी युक्त हर लाइन पर, cdnइसे बदलें dn, डुप्लिकेट में न्यूलाइन के बिना डुप्लिकेट और आउटपुट के बराबर

अब इसका मूल्यांकन dc अभिव्यक्ति के रूप में किया जाता है।

— user41805
स्रोत
2
मुझे लगता है sedकि जब गोल्फ खेलना शुरू होता है तो सिंटैक्स से पहले से भी अधिक विदेशी बनने की उम्मीद करना अनुचित नहीं है ।
— मतीन उल्हाक
6

जेली , 21 बाइट्स

ḲḢ€O%11ị⁾’‘j“IȮḤH”¤VI

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

ध्यान दें कि पहले वर्णों के ASCII मान ( idmhPe) मोडुलो ११ अद्वितीय मोडुलो ६ हैं।

मोडुलो 16 का उपयोग करना:

जेली , 21 बाइट्स

ḲḢ€O%⁴ị“ḢwġḞkz’ṃØJ¤VI

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

जिस स्ट्रिंग को अनुक्रमित करने के लिए उपयोग किया जाता है ḤH‘’IȮवह इस मामले में है। ‘’सीमाओं पर नहीं रह रहे हैं।

— user202729
स्रोत
6 बाइट स्ट्रिंग का प्रतिनिधित्व करने के लिए 11 बाइट्स का उपयोग करना ... बहुत बुरा है। लेकिन ... “”2 बाइट्स ¤लेता है , 1 बाइट लेता है, डेटा खुद 6 बाइट्स लेता है, कुछ करने के लिए 2 बाइट्स बचे हैं। वर्तमान में यह है ⁾और j, लेकिन ịØJया ṃØJबहुत बदतर है, और Ọकाम नहीं करता है (क्योंकि यूनिकोड)।
— user202729
जेली की स्ट्रिंग अवधारणा ("एक स्ट्रिंग मुद्रण को प्रभावित करने के लिए एक विशेष ध्वज के साथ पूर्णांक की एक सूची है") महान है।
— user202729
5

आर , 128 125 बाइट्स

Reduce(function(x,y)switch(y,i=x+1,d=x-1,m=x*2,h=x/2,P={cat(x);x}),substr(el(strsplit(gsub("e.*$","",scan(,""))," ")),1,1),0)

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

source(echo=FALSE)रिटर्न वैल्यू को अपने आप प्रिंट होने से रोकने के लिए बुलाया जाना चाहिए । विकल्प सब कुछ लपेटने केinvisible लिए होगा , लेकिन यह बहुत कम गोल्फ है (और मेरी [अभी भी] अच्छी बाइट गिनती को बर्बाद कर देता है)।

— ग्यूसेप
स्रोत
3

05AB1E , 25 बाइट्स

΀¬"idmhPe"S"><·;=q"S‡J.V

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

इसी 05AB1E फ़ंक्शन (प्रत्येक फ़ंक्शन के पहले चार्ट का उपयोग करके) के साथ भाषा फ़ंक्शन में से प्रत्येक को मैप करें, और फिर परिणामी स्ट्रिंग को 05AB1E कोड के रूप में निष्पादित करता है।

— Kaldo
स्रोत
2

पायथन 2 , 131 125 122 121 118 117 115 बाइट्स

v=0;o=""
for x in input().split("x")[0].split():
 if"Q">x:o+=`v`
 else:v+=(1,-1,v,-v/2.)['idmh'.find(x[0])]
print o

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

-6 और -3 @Rod के साथ धन्यवाद

-3 और -2 @etene धन्यवाद के साथ

-1 की जगह "Pri"==xके साथ"P"in x

— ElPedro
स्रोत
आप कर सकते हैं splitपर "exit"और 1 ब्लॉक मिलता है, बजाय breaking 4 बाइट बचत
— रॉड
1
आप चारों ओर कोष्ठकों को हटा सकते हैं 'idmh'और findइसके स्थान पर उपयोग कर सकते हैं index, इससे कुछ बाइट्स
— बचेंगे
@Rod - वास्तव में थोड़ा और आगे ले जा सकता है और exएक और 2 को बचाने के लिए अलग हो सकता है
— ElPedro
आप इसके v=(v+1,v-1,v*2,v/2.)साथ v+=(1,-1,v,-v/2.)काम कर सकते हैं, हालांकि इसका परीक्षण नहीं किया जाना चाहिए
— रॉड
@Rod - उस के बारे में सोचा था, लेकिन यह काम नहीं कर सका कि कैसे करना है half। बहुत आसन! धन्यवाद।
— ElPedro
2

पायथन 3 , 110 91 82 बाइट्स

exit एक त्रुटि के साथ प्रोग्राम से बाहर निकलने का कारण होगा।

x=0
for c in input():c=='P'==print(x,end='');x+=(1,-1,x,-x/2,c,0)['ndmhx'.find(c)]

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

— mbomb007
स्रोत
9 बाइट्स को बचाने के लिए अपने चर नामों को छोटा करें। i='x+=1';d='x-=1';...और फिर अपनी execकॉल में, इसे बदल देंexec(eval(c[0]))
— mypetlion
@mypetlion धन्यवाद, लेकिन मुझे एक बेहतर तरीका मिला।
— mbomb007
मुझे लगता है कि यह मान्य है: 82 बाइट्स
— लिन
@ लियन यह बहुत अच्छा है! मैं printबयान के लिए शॉर्ट-सर्किट का एक अच्छा तरीका नहीं सोच सकता था !
— mbomb007
2

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

@ L4m2 के लिए धन्यवाद 4 बाइट्स सहेजे गए

Iteratively निर्देशों को आउटपुट या रिक्त स्ट्रिंग्स के साथ बदलता है।

s=>s.replace(/\S+./g,w=>m<s?'':w<{}?m:(m+={d:-1,e:w,i:1,m}[w[0]]||-m/2,''),m=0)

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

टिप्पणी की गई

s =>                       // given the input string s
  s.replace(/\S+./g, w =>  // for each word w in s:
    m < s ?                //   if m is a string:
      ''                   //     ignore this instruction
    :                      //   else:
      w < {} ?             //     if w is 'Pri' ({} is coerced to '[object Object]'):
        m                  //       output the current value of m
      : (                  //     else:
          m +=             //       add to m:
            { d: -1,       //         -1 if w is 'dec'
              e: w,        //         w  if w is 'exit' (which turns m into a string)
              i: 1,        //         1  if w is 'inc'
              m            //         m  if w is 'mult'
            }[w[0]]        //       using the first character of w to decide
            || -m / 2,     //       or add -m/2 (for 'half') if the above result was falsy
        ''),               //       do not output anything
    m = 0                  //   m = unique register of our mighty CPU, initialized to 0
  )                        // end of replace()
— Arnauld
स्रोत
s=>s.replace(/\S+./g,w=>k<s?'':w<{}?k:(k+={d:-1,e:w,i:1,m:k}[w[0]]||-k/2,''),k=0)
— l4m2
@ यह l4m2 w<{}p: शुद्ध बुराई है
— Arnauld
s=>s.replace(/\S+./g,e=>m<s?'':e<{}?m:(m+={d:-1,e,i:1,m}[e[0]]||-m/2,''),m=0)काम भी
— l4m2
2

चारकोल , 37 35 बाइट्स

≔⁰ηＦ⎇№θx…θ⌕θxθ≡ιn≦⊕ηd≦⊖ηm≦⊗ηh≦⊘ηrＩη

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। @ RickHitchcock के जवाब से प्रेरित। स्पष्टीकरण:

≔⁰η

चर साफ़ करें।

Ｆ⎇№θx…θ⌕θxθ≡ι

xयदि एक है, तो इनपुट को काटें और फिर इनपुट के प्रत्येक (शेष) अक्षर पर लूप ओवर और स्विच करें।

n≦⊕η

nमैं n चर crements।

d≦⊖η

d d परिवर्तनशील चर।

m≦⊗η

m m चर को दो (यानी दोगुना) कर देता है।

h≦⊘η

h ज चरती है।

rＩη

rp r स्ट्रिंग में वेरिएबल कास्ट को इन्टस करता है।

— नील
स्रोत
1
@RickHitchcock क्षमा करें, यह पूरी तरह से पर्याप्त परीक्षण नहीं किया। मुझे एक वर्क अराउंड मिला, लेकिन इसमें मुझे एक बाइट का खर्च करना पड़ा।
— नील
2

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

(उधार लिया हुआ ( चुराया हुआ ) @ अरण्युलद की mचर नाम के रूप में उपयोग करने की ट्रिक , 2 बाइट्स की बचत।)

f=([c,...s],m=0)=>c<'x'?(c=='P'?m:'')+f(s,m+({h:-m/2,d:-1,n:1,m}[c]||0)):''

प्रति निर्देश के अनुसार अलग-अलग अक्षरों की तलाश करते हुए और बाकी को नजरअंदाज करते हुए पुन: स्ट्रिंग पर चलते हैं:

  • n: इंक
  • डी: डिक
  • m: बहु
  • ज: आधा
  • P: Pri
  • x: बाहर निकलें

इस तथ्य का लाभ उठाता है कि undefinedन तो इससे अधिक है और न ही इससे कम है 'x', जिससे पुनरावृत्ति स्ट्रिंग के अंत में रुक जाती है या जब यह निकास'x' में सामना करती है ।

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

— रिक हिचकॉक
स्रोत
1
आपकी हटाई गई टिप्पणी तक, जिसके बाद मैं निश्चित रूप से उत्तर नहीं दे सकता, मैं सही (डीओएच!) लिंक में पेस्ट करना भूल गया था, लेकिन मुझे एक नया तरीका मिला जो मेरे मूल प्रयास की तुलना में 2 बाइट्स कम है।
— नील
1

जावास्क्रिप्ट (Node.js) , 107 बाइट्स

f=s=>s.split` `.map(([o])=>F?0:o=="i"?i++:o=="d"?i--:o=="m"?i*=2:o=="h"?i/=2:o=="P"?S+=i:F=1,F=i=0,S="")&&S

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

— DanielIndie
स्रोत
इसे तब तक 105 बाइट्स के रूप में गिना जाना चाहिए, जब तक कि आपका फ़ंक्शन खुद को कॉल नहीं करता है आपको गिनती करने की आवश्यकता नहीं है f=
— ब्रायन एच।
1

जावास्क्रिप्ट (Node.js) , 91 बाइट्स

_=>_.split` `.map(o=>o<{}>!_?S+=+i:o<"e"?i--:o<"f"?++_:o<"i"?i/=2:o<"j"?i++:i*=2,i=S="")&&S

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

जावास्क्रिप्ट (Node.js) , 96 बाइट्स

_=>_.split` `.map(o=>F?0:o<"Q"?S+=i:o<"e"?i--:o<"f"?F=1:o<"i"?i/=2:o<"j"?i++:i*=2,F=i=0,S="")&&S

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

जावास्क्रिप्ट (Node.js) , 99 बाइट्स

s=>s.split` `.map(_=>eval('++i7--i7++e7u+=+i7i*=27i/=2'.split(7)[Buffer(e+_)[0]%11%6]),e=i=u='')&&u

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

— l4m2
स्रोत
1

लूआ, 207 बाइट्स

s=0;n=0;for a in io.read():gmatch'.'do if s==0 then s=1;n=a=='i'and n+1 or a=='d'and n-1 or a=='m'and n*2 or a=='h'and n/2 or n;if a=='P'then print(n)elseif a=="e"then break end elseif a==' 'then s=0 end end
— जुझार सिंह
स्रोत
1

पायथन 3 , 114 110 109 116 बाइट्स

वास्तव में पायथन 2 में दो बाइट कम लिया गया होगा क्योंकि execएक बयान है और कोष्ठक की जरूरत नहीं है ...

  • @ElPedro के लिए 4 अतिरिक्त बाइट्स को सहेजा गया

  • इस तथ्य का लाभ उठाकर एक अतिरिक्त बाइट को बचाया कि find-1 त्रुटि पर लौटाता है, जिसे बाद में एक सूचकांक के रूप में इस्तेमाल किया जा सकता है

  • +7 बाइट्स क्योंकि मैंने नो-न्यूलाइन्स नियम पर ध्यान नहीं दिया था :(

i=0;exec(";".join("i+=1 i-=1 i*=2 i/=2 print(i,end='') exit()".split()["idmhP".find(h[0])]for h in input().split()))

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

पायथन कोड का एक टुकड़ा करने के लिए हर इनपुट शब्द का पहला चरित्र मैप। ये तो संघातित हैं औरexec संपादित होते हैं।

बहुत सरल दृष्टिकोण, कि शायद थोड़ा और अधिक गोल्फ हो सकता है। कठिनाई ज्यादातर कई संभावित लोगों में से सबसे छोटा रूप खोजने में रहती है ...

— etene
स्रोत
112 ऑनलाइन कोशिश करो! यदि आपके पास एक स्थान अलग स्ट्रिंग के रूप में कमांड है और इसे विभाजित करें।
— ElPedro
1
110 के रूप में वास्तव में कोष्ठक जा सकते हैं यह ऑनलाइन कोशिश करो!
— एलपीड्रो
यह सही आउटपुट नहीं देता है। प्रश्न कहता है कि आपको विभाजकों के बिना प्रिंट करना होगा, इसलिए आपको आवश्यकता है print(i,end='')। 4 वां परीक्षण मामला देखें।
— mbomb007
मैंने ध्यान नहीं दिया, मैं इसे ठीक कर दूँगा। धन्यवाद !
— इथेन
@etene टिप्पणी जब आपने इसे ठीक कर लिया है और मैं अपना डाउनवोट हटा दूंगा।
— mbomb007
1

रूबी + -na, 81 73 65 बाइट्स

x=0;$F.map{|w|eval %w{x+=1 x-=1 1/0 $><<x x*=2 x/=2}[w.ord%11%6]}

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

बहुत सीधा। प्रत्येक शब्द के पहले अक्षर के लिए, संबंधित कमांड स्ट्रिंग और evalइसे ढूंढें । पूर्णांक विभाजन का उपयोग करता है, और exitsफेंकने से ZeroDivisionError।

-5 बाइट्स: .ord%11%6एक स्ट्रिंग लुकअप के बजाय उपयोग करें । श्रेय जाता है user202729

-3 बाइट्स: .ordकेवल स्ट्रिंग के पहले चरित्र पर विचार करता है, इसलिए मैं ए को छोड़ सकता हूं [0]।

-8 बाइट्स: किरील एल के-a लिए स्वचालित रूप से इनपुट को विभाजित करने के लिए ध्वज का उपयोग करें ।

— benj2240
स्रोत
1
आप को जोड़कर और भी अधिक बाइट्स बचा सकता है -aविकल्प की तरह, आप के लिए autosplit करने के लिए इस
— किरिल एल
1

इमोजीकोड , 270 बाइट्स

🐖🔥🍇🍮c 0🔂j🍡💣🐕🔟 🍇🍊😛j🔤inc🔤🍇🍮c➕c 1🍉🍋😛j🔤dec🔤🍇🍮c➖c 1🍉🍋😛j🔤mult🔤🍇🍮c✖️c 2🍉🍋😛j🔤half🔤🍇🍮c➗c 2🍉🍋😛j🔤Pri🔤🍇👄🔡c 10🍉🍓🍇🍎🍉🍉🍉

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

🐋🔡🍇
🐖🔥🍇
🍮c 0
🔂j🍡💣🐕🔟 🍇
🍊😛j🔤inc🔤🍇🍮c➕c 1🍉
🍋😛j🔤dec🔤🍇🍮c➖c 1🍉
🍋😛j🔤mult🔤🍇🍮c✖️c 2🍉
🍋😛j🔤half🔤🍇🍮c➗c 2🍉
🍋😛j🔤Pri🔤🍇👄🔡c 10🍉
🍓🍇🍎🍉🍉🍉🍉

🏁🍇
 🔥🔤inc inc inc dec Pri exit🔤
😀🔤🔤
 🔥🔤dec inc mult inc inc Pri🔤
😀🔤🔤
 🔥🔤inc inc inc mult half Pri exit inc🔤
😀🔤🔤
 🔥🔤inc Pri inc Pri inc Pri exit half mult🔤
😀🔤🔤
 🔥🔤Pri exit🔤
😀🔤🔤
 🔥🔤inc half Pri exit🔤
🍉
— X1M4L
स्रोत
0

SNOBOL4 (CSNOBOL4) , 165 बाइट्स

	P =INPUT ' exit ' 
	x =0
S	P LEN(1) $ L ARB ' ' REM . P	:S($L)F(end)
i	X =X + 1	:(S)
d	X =X - 1	:(S)
P	O =O X		:(S)
m	X =X * 2	:(S)
h	X =X / 2.	:(S)
e	OUTPUT =O
END

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

कुल।

	P =INPUT ' exit ' 				;* append ' exit ' to the input to guarantee that the program will stop
	x =0						;* initialize x to 0 else it won't print properly if the program is 'Pri'
S	P LEN(1) $ L ARB ' ' REM . P	:S($L)F(end)	;* set L to the first letter of the word and goto the appropriate label
i	X =X + 1	:(S)
d	X =X - 1	:(S)
P	O =O X		:(S)				;* append X to the output string
m	X =X * 2	:(S)
h	X =X / 2.	:(S)				;* divide by 2. to ensure floating point
e	OUTPUT =O					;* print whatever's in O, which starts off as ''
END
— ग्यूसेप
स्रोत
0

सी # (.NET कोर), 186 बाइट्स

class P{static void Main(string[]a){int v=0;foreach(var s in a){var i=s[0];if(i=='i')v++;if(i=='d')v--;if(i=='m')v*=2;if(i=='h')v/=2;if(i=='P')System.Console.Write(v);if(i=='e')break;}}}
— Romen
स्रोत
आप कुछ सरल काम करके 26bytes को शेव कर सकते हैं, जैसे कि घोषित iकरना v, ASCII तालिका से परामर्श करना ताकि आप छोटी संख्याओं का उपयोग कर सकें, एस को फिर से व्यवस्थित कर सकें ifऔर फिर एक टर्नरी का उपयोग कर सकें : class Z{static void Main(string[]a){int v=0,i;foreach(var s in a){i=s[0]%'d';if(i==1)break;if(i>9)System.Console.Write(v);else v=i<1?v-1:i<5?v/2:i<6?v+1:v*2;}}}(PS यह कैसे काम करता है और कैसे उपयोग करना है इसका स्पष्टीकरण यह (जैसे कमांड लाइन
— आर्ग्स
(ओह जो शर्मनाक है ... मुझे %50इसके बजाय उपयोग करना चाहिए %'d')
— विजुअलमेलन
0

पर्ल 5 -a , 61 बाइट्स

eval'$,'.qw(++ -- ;exit ;print$,||0 *=2 /=2)[(ord)%11%6]for@F

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

चोरी @ user202729 की ord%11%6चाल

कैसे?

-a            # split the input by whitespace, store in @F
eval          # Execute the string that results from:
'$,'          # $, (the accumulator)
.             # appending:
qw(           # create an array for the following whitespace separated values:
++ --            # operators for inc & dec
;exit            # exit
;print$,||0      # Pri  (||0 ensures that 0 is output if accumulator is null
*=2 /=2)         # mult div
[(ord)%11%6] # @user202729's trick selects one of the preceding operations
for@F        # for every term input
— Xcali
स्रोत
0

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

Vmx"idmhPe"hdcwd=Z@[hZtZyZcZ2ZZ)NIqN4pZIqN6B

परीक्षण सूट

व्याख्या

Vmx"idmhPe"hdcwd=Z@[hZtZyZcZ2ZZ)NIqN4pZIqN6B   ## full program
             cwd                               ## split input on space
Vmx"idmhPe"hd                                  ## iterate through list of numbers corresponding to operators
                =Z@[hZtZyZcZ2ZZ)N              ## assign the variable Z (initialliy Zero) it's new value
                                 IqN4pZ        ## print Z if the current operator is "Pri" (4)
                                       IqN6B   ## break if the current operator is "exit" (5)
— KarlKastor
स्रोत
0

टीआई-बेसिक, 112 बाइट्स

यह कुछ मान्यताओं का लाभ उठाता है जो AFAIK पूरी तरह से स्वीकार्य हैं। नंबर एक कि सभी चर निष्पादन से पहले शून्य से शुरू होते हैं; नंबर दो उस इनपुट के माध्यम से लिया जाता है Ans।

Ans+" E→Str1
While 1
I+4→I
sub(Str1,I-3,1→Str2
A+(Ans="I")-(Ans="D
If inString("MH",Str2
Then
I+1→I
2AAns+A/2(1-Ans
End
If Str2="P
Disp A
If Str2="E
Stop
Ans→A
End
— kamoroso94
स्रोत
0

जावा (ओपनजेडके 8) , 164 बाइट्स

a->{int c=0;for(String g:a.split(" ")){char b=g.charAt(0);if(b==105)c++;if(b==100)c--;if(b==109)c*=2;if(b==104)c/=2;if(b==80)System.out.print(c);if(b==101)return;}}

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

ऊपर मेरा समाधान है जो पूर्णांक के लिए बंद है, लेकिन नीचे मेरा समाधान है जो दशमलव को संभालता है। जावा को प्रिंट करने वाला अप्रिय तरीका स्कोर में एक और 55 बाय जोड़ता है। मैंने कोड को दूसरी सबमिशन में अधिक पठनीय बनाने के लिए नई लाइनें छोड़ दीं क्योंकि यह अनिवार्य रूप से एक अतिरिक्त कमांड और आयात स्टेटमेंट के साथ एक ही समाधान है।

जावा (ओपनजेडके 8) , 219 बाइट्स

a->{
double c=0;
for(String g:a.split(" ")){
char b=g.charAt(0);
if(b==105)c++;
if(b==100)c--;
if(b==109)c*=2;
if(b==104)c/=2;
if(b==80)System.out.print(new DecimalFormat("0.#").format(c));
if(b==101)return;}}

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

— X1M4L
स्रोत
0

सी (जीसीसी) , 120 114 111 बाइट्स

-6 बाइट्स सीलिंगकैट के लिए धन्यवाद।

x,d;f(char*s){for(x=0;s>1;s=index(d^1?s:"",32)+1)d=*s-100,x+=d?d==5:-1,x*=d^9?d^4?1:.5:2,d+20||printf("%d",x);}

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

124 बाइट्स

फ़्लोटिंग-पॉइंट संस्करण:

d;f(char*s){for(float f=0;s>1;s=strchr(s,32)+1)d=*s-80,f+=d==25,f-=d==20,f*=d^29?d^24?1:.5:2,s=d^21?s:"",d?:printf("%f",f);}

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

मैं एक ऐसे संस्करण से परेशान नहीं था जो नीचे गोल हो गया था, लेकिन 0 के लिए एक अपवाद बनाता है, जिसे अनुमति दी जाएगी, अगर मैं टिप्पणी-श्रृंखला को सही ढंग से समझता हूं।

— gastropner
स्रोत
0

33 , 62 बाइट्स

s'i'{1a}'d'{1m}'m'{2x}'h'{2d}'P'{o}'e'{@}It[mzsjk""ltqztItn1a]

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

यह कार्यक्रम निर्देश को नए सिरे से सीमांकित करता है

स्पष्टीकरण:

It[mzsjk""ltqztItn1a]
  [mz            n1a] | Forever
It    jk       It     | - Get the first character of the next instruction
            qz        | - Call the function declared previously
     s  ""lt  t       | - Make sure we don't lose track of the variable

उस खंड से पहले का कोड सभी कार्यों को परिभाषित करता है।

— TheOnlyMrCat
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.