मूल कैलकुलेटर

Question

आपको एक स्ट्रिंग का मूल्यांकन करने के लिए एक प्रोग्राम लिखना होगा जो एक कैलकुलेटर में दर्ज किया जाएगा।

कार्यक्रम को इनपुट स्वीकार करना चाहिए और सही उत्तर का उत्पादन करना चाहिए। उन भाषाओं के लिए जिनके पास मानक इनपुट / आउटपुट फ़ंक्शन नहीं हैं, आप फ़ंक्शन readLineऔर मान सकते हैं print।

आवश्यकताएँ

• किसी भी तरह के "eval" फ़ंक्शन का उपयोग नहीं करता है
• फ्लोटिंग पॉइंट और नेगेटिव नंबर को हैंडल कर सकते हैं
• कम से कम +, -, *, और / ऑपरेटरों का समर्थन करता है
• ऑपरेटरों और नंबरों के बीच एक या अधिक रिक्त स्थान वाले इनपुट को संभाल सकते हैं
• बाएं से दाएं की अभिव्यक्ति का मूल्यांकन करता है

जो कार्यक्रम सबसे कम जीतता है। एक टाई होने की स्थिति में, जो कार्यक्रम प्रस्तुत किया गया था वह पहले जीत गया था।

आप मान सकते हैं कि इनपुट वैध है और सही प्रारूप का अनुसरण करता है

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

इनपुट

-4 + 5

उत्पादन

1

---

इनपुट

-7.5 / 2.5

उत्पादन

-3

---

इनपुट

-2 + 6 / 2 * 8 - 1 / 2.5 - 18

उत्पादन

-12

Comments

मेरे कैलकुलेटर पोस्टफिक्स का उपयोग करता है । प्रतियोगिता के लिए स्टैक ओवरफ्लो पर गणितीय अभिव्यक्तियों का मूल्यांकन करना भी देखें (हालांकि मैंने जांच नहीं की है कि क्या नियम समान हैं)।

— dmckee

तीसरा परीक्षण मामला गलत है - चाहे आप संचालन के मानक आदेश का पालन करते हैं या दाएं से बाएं सभी ऑपरेशन करते हैं। दूसरे परीक्षण मामले को देखते हुए, क्या आपका कैलकुलेटर प्रत्येक ऑपरेशन के परिणाम को गोल करता है?

— कृपया 19

दूसरे और तीसरे परीक्षण के मामले को तय किया, परिणाम गोल नहीं है।

— केविन ब्राउन

तीसरा परीक्षण मामला संचालन के मानक आदेश का पालन नहीं करता है। क्या हमारे उत्तरों को माना जाता है?

— जॉन

कमांड लाइन तर्क ARGV का उपयोग करने के बारे में क्या? क्योंकि शेल ऑटो-विभाजन करता है और तर्कों को सूचीबद्ध करता है।

— मिंग-तांग

Answer 1

रूबी - 74 69 67 65 वर्ण

a=0
("+ "+$<.read).split.each_slice 2{|b,c|a=a.send b,c.to_f}
p a

Comments

उपयोग करने के बजाय b[0],b[1].to_fआप के |b|साथ बदल सकते हैं और उपयोग कर सकते |b,c|हैंb,c.to_f

— निमो 157

\ o / धन्यवाद! :-)

— अरनौद ले ब्लांक

इसके बजाय a.send(b,c.to_f), उपयोग करें a.send b,c.to_f। यह

— कायर

आप $<इसके बजायARGF

— Dogbert

Answer 2

Befunge - 37 x 5 = 185 38 x 3 = 114 वर्ण

यह पूर्णांक संख्या तक सीमित है क्योंकि Befunge में फ्लोटिंग पॉइंट सपोर्ट नहीं है।

&v      /& _ #`&# "-"$# -#<          v
 >~:0`!#v_:" "`! #v_:","`#^_"*"`#v_&*>
 ^      ># $ .# @#<              >&+ 

व्याख्या

Befunge की सबसे बड़ी विशिष्ट विशेषता यह है कि इसके बजाय अधिकांश भाषाओं की तरह निर्देशों का रैखिक सेट है; यह एकल चरित्र निर्देशों का 2 डी ग्रिड है, जहां नियंत्रण किसी भी दिशा में प्रवाहित हो सकता है।

पहला &सरलता से पहला नंबर इनपुट करता है। vऔर >उसके बाद दूसरी पंक्ति पर मुख्य पथ के लिए रीडायरेक्ट नियंत्रण।

~:0`!#v_

यह एक चरित्र इनपुट करता है ( ~), इसे डुप्लिकेट करता है ( :), स्टैक पर शून्य को धक्का देता है ( 0), शीर्ष दो तत्वों को पॉप करता है और निर्धारित करता है कि क्या दूसरा पहले से अधिक है ( ` मुझे आश्चर्य है कि आप पाने के लिए `` का उपयोग नहीं कर सकते हैं) कोड backticks। );) शीर्ष तत्व की सत्यता का संकेत देता है ( !), फिर सही हो जाता है अगर यह शून्य है, तो नीचे (अन्यथा #v_)।

मूल रूप से यह जाँच कर रहा है कि इनपुट -1अधिक इनपुट का प्रतिनिधित्व कर रहा है या नहीं।

># $ .# @

यदि इनपुट था -1तो डुप्लिकेट किए गए इनपुट मान को छोड़ दिया गया है ( $), स्टैक के शीर्ष पर पूर्णांक ( .) के रूप में आउटपुट है और प्रोग्राम रुका हुआ है ( @)।

:" "`! #v_

अन्यथा एक समान प्रक्रिया यह निर्धारित करने के लिए दोहराई जाती है कि इनपुट अंतरिक्ष से कम या बराबर है। यदि यह एक स्थान है तो नियंत्रण नीचे चला जाता है, अन्यथा सिर को ठीक से नियंत्रित करें।

^      ># $ .# @#<

यदि यह एक स्थान है तो इसे बाईं ओर पुनर्निर्देशित किया गया है ( <); कार्यक्रम रुक ( @), आउटपुट ( .) और सही पुनर्निर्देशन ( >) सभी का उपयोग कर छोड़ दिया जाता है #; लेकिन स्टैक से स्थान को हटाने के लिए डिसकस निष्पादित किया जाता है। अंत में इसे अगले निष्पादन को शुरू करने के लिए पुनर्निर्देशित किया गया है ^।

:","`#^_

यदि यह एक अंतरिक्ष एक ही प्रक्रिया पर विभाजित करने के लिए करता है, तो उस में है प्रयोग किया जाता है नहीं था [+, *]या में [-, \]सही और ऊपर क्रमशः जा रहा है।

 >~                         "*"`#v_&*>
 ^                               >&+

इसके लिए [+, *]यह निर्धारित करने के लिए फिर से विभाजित किया जाता है कि क्या यह एक +या एक है *। यदि +इसे नीचे निर्देशित किया जाता है तो अगला नंबर इनपुट ( &) है और उन्हें जोड़ा जाता है ( +), नियंत्रण फिर चारों ओर लपेटता है और अगले वर्ण के लिए मुख्य पथ पर पुनर्निर्देशित किया जाता है। यदि *यह इनपुट ( &) और कई गुना ( *) है तो सीधे चारों ओर लपेटता है।

/& _ #`&# "-"$# -#<

इसके [-, \]लिए दाईं ओर बाईं ओर शुरू होता है। #'एस उनके पीछे चरित्र को छोड़ तो प्रारंभिक मार्ग है "-"`_अगर यह होता है जो केवल निर्धारित करता है -या /। यदि ऐसा है /तो यह इनपुट ( &) और डिवाइड ( /) पर छोड़ दिया जाता है । यदि यह -तब सही है, तो फिर से वर्णों को छोड़ देना ताकि यह निष्पादित हो जाए &"-"$-जिसके परिणामस्वरूप संख्या इनपुट हो जाए ( &) -वर्ण को स्टैक पर धकेला जा रहा है, फिर छोड़ दिया ( "-"$) और फिर घटाव की गणना की जा रही है ( -)। नियंत्रण को फिर से मुख्य पथ पर भेज दिया जाता है।

Answer 3

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

चार बुनियादी संचालन का प्रबंधन करता है, लेकिन इसे जोड़ने ^या करने के लिए केवल 5 वर्णों की लागत होती है %।

f=float
x,*l=input().split()
while l:o,y,*l=l;x,y=f(x),f(y);x=[x+y,x-y,x*y,x/y]['+-*/'.find(o)]
print(x)

संचालन की प्राथमिकता को दाईं ओर छोड़ दिया गया है।

Answer 4

पायथन (156)

from operator import*
while 1:
 l=raw_input().split();f=float
 while len(l)>2:l[:3]=({'*':mul,'/':div,'+':add,'-':sub}[l[1]](f(l[0]),f(l[2])),)
 print l[0]

Comments

यह संभव है कि Python 3

— jamylak

Answer 5

C - 168 126 वर्ण

main(c){float a,b;scanf("%f",&a);while(scanf("%s%f",&c,&b)!=-1)c=='+'?a+=b:c=='-'?(a-=b):c=='*'?(a*=b):(a/=b);printf("%f",a);}

Answer 6

Tcl 8.6, 57 48 वर्ण।

• तर्कों से इनपुट:

  lm o\ b [las $argv a] {set a [exp $a$o$b]};pu $a
  

• स्टडिन ( 64 53 ) से

  lm o\ b [las [ge stdin] a] {set a [exp $a$o$b]};pu $a
  

आपको दोनों समाधानों के लिए इंटरैक्टिव शेल का उपयोग करना होगा।

मैं सूची के रूप में इनपुट का इलाज पहले तत्व लेने के लिए और यह आवंटित करने के लिए (Tcl परिसीमक के रूप में रिक्त स्थान का उपयोग करता है) a, तो मैं बाकी पर चलने, 2 तत्वों हर बार, ऑपरेटर और एक दूसरे नंबर ले, पर ऑपरेटर लागू $aऔर $bऔर आवंटित परिणाम a। अंत में परिणाम सामने है a।

Comments

Ideone कम से कम स्टड का समर्थन करता है।

— जोहान्स कुह्न

अंत में, मैंने रूबी को हराया। दुर्भाग्य से Idone Tcl 8.6 का समर्थन नहीं करता है, लेकिन मैं परिणाम की जरूरत नहीं है की lmapइतना foreachएक अच्छा प्रतिस्थापन है।

— जोहान्स कुह्न

Answer 7

हास्केल: 124 114 वर्ण

j[o]=o
j(u:m:b:o)=j$show((case m of{"+"->(+);"-"->(-);"*"->(*);"/"->(/)})(read u)(read b)):o
main=interact$j.words

भारी मिलान के लिए पैटर्न मिलान और एक साधारण केस स्टेटमेंट का उपयोग करते हुए, बल्कि सीधा-सीधा उत्तर। उपयोग:

> ./calc <<< "123 - 12 + -12 / 12.124 * 9.99 - 1"
80.57456285054437

Comments

इसके बजाय ((case m of{..})(read u)(read b))आप लिख सकते हैं ((case m of{..}$read u)$read b), 2 अक्षर कम।

— बेंत की मार

Answer 8

C: 111 108 वर्ण

main(c){float a,b;for(scanf("%f ",&a);~scanf("%c%f ",&c,&b);a=c^43?c%5?c%2?a/b:a*b:a-b:a+b);printf("%f",a);}

यह सभी आवश्यकताओं को पूरा करता है, उपयोग:

> ./calc <<< "-43 - 56 + 14.123 / -13.22"
6.420348

Comments

~scanfप्रतिस्थापित कर सकता है +1। इसके अलावा, c^45-> c%5और c^42-> c%2काम करना चाहिए।

— बदमाश

@MDXF मेरी मशीन पर नहीं है, यह यहाँ हर टेस्ट केस को पास करता है। मैं काफी आधुनिक इंटेल मैकबुक पर क्लैंग के साथ संकलन कर रहा हूं, और यह अच्छी तरह से काम करता है (मैंने इसे अभी-अभी फिर से परीक्षण किया, मैंने यहां से कोड को कॉपी किया और बस इसे बिना किसी झंडे के संकलित किया)। आप किस कंपाइलर, प्रोसेसर आर्किटेक्चर और ओएस का उपयोग कर रहे हैं?

— फोर्स

@ मुझे विश्वास है कि मेरे पास कुछ अजीब झंडे थे जो अजीब व्यवहार को प्रेरित कर रहे थे; मेरी गलती, यह अब मेरे लिए काम कर रहा है। आपको परेशान करने के लिए माफी चाहता हूं।

— एमडी एक्सएफ

Answer 9

सी ++ 0x 205 203 198 194 वर्ण

#include<iostream>
#define P [](F l,F r){return l
int main(){typedef float F;F r,v,(*a[])(F,F)={P*r;},P+r;},0,P-r;},0,P/r;}};std::cin>>r;for(char o;std::cin>>o>>v;)r=a[o-42](r,v);std::cout<<r;}

अच्छी तरह से स्वरूपित:

#include<iostream>

int main()
{
    float r,v;
    float (*a[])(float,float)   ={  [](float l,float r){return l*r;},
                                    [](float l,float r){return l+r;},
                                    0,
                                    [](float l,float r){return l-r;},
                                    0,
                                    [](float l,float r){return l/r;}
                                 };

    std::cin>>r;
    for(char o;std::cin>>o>>v;)
        r=a[o-42](r,v);

    std::cout<<r;
}

Answer 10

पर्ल (97)

$b=shift;eval"\$b$r=$s"while($r=shift,$s=shift);print$b

तर्कों से पढ़ें

$b=shift;$b=($r eq'+'?$b+$s:$r eq'-'?$b-$s:$r eq'*'?$b*$s:$b/$s)while($r=shift,$s=shift);print$b;

इनपुट से पढ़ें

@_=split/ /,<>;$b=shift@_;$b=($r eq'+'?$b+$s:$r eq'-'?$b-$s:$r eq'*'?$b*$s:$b/$s)while($r=shift@_,$s=shift@_);print$b

Answer 11

पोस्टस्क्रिप्ट (145)

एक और पोस्टस्क्रिप्ट प्रविष्टि (पोस्टस्क्रिप्ट के लिए दिलचस्प गोल्फ को खोदने के लिए लूसर ड्रॉग के लिए धन्यवाद!)।

[/+{add}/-{sub}/*{mul}/{div}>>begin(%stdin)(r)file
999 string readline
pop{token not{exit}if
count 4 eq{3 1 roll
4 1 roll
cvx exec}if
exch}loop
=

संयुक्त राष्ट्र के golfed:

[/+{add}/-{sub}/*{mul}/ {div}>>begin
% Read the input
(%stdin)(r)file 999 string readline pop
{                        % .. string
  token not{exit}if      % .. string token
  % If we have 4 objects on the stack, we have two operands, one operator
  % and the input string. This means, we can calculate now.
  count 4 eq{            % a op string b
    % perform operation a op b = c (where op can be +,-,*,/)
    3 1 roll             % a b op string
    4 1 roll             % string a b op 
    cvx exec             % string c
  }if                    % string token (or c)
  exch                   % token string
}loop
=

Comments

तुम मुझे पीटते रहो! +1 यह बहुत ही रोमांचक है।

— लूसर ड्रोग

यदि आप मेरे क्रॉसवर्ड को हरा सकते हैं , तो मैं आपको एक इनाम दूंगा! एनबी आप केवल 10 बार संपादित कर सकते हैं इससे पहले कि पोस्ट सीडब्ल्यू बन जाए और वोट आपको पुन: अंक अर्जित न करें।

— luser droog

मैं तुम्हें पीटता रहता हूं क्योंकि मैंने केवल उन लोगों को चुना है जहां मैं तुम्हें हरा सकता हूं ;-)। मुझे यकीन नहीं है कि मैं क्रॉसवर्ड ग्रिड के साथ कर सकता हूं। मैं शायद कोशिश करूँगा, लेकिन केवल कुछ हफ्तों में।

— थॉमस डब्ल्यू।

सामुदायिक विकी इसका मतलब है कि पोस्ट को अब तक कई बार संपादित किया गया है जो अब समुदाय से संबंधित है। कोई भी उपयोगकर्ता इसे संपादित कर सकता है (सामान्य रूप से सुझाए गए संपादन के लिए आवश्यक मॉडरेटर की मंजूरी को दरकिनार करके ), और अधिक अंक नहीं। इसलिए आप जो कुछ भी करते हैं, वह Rev 9. पर बंद हो जाता है। मैंने इसे गिटार टैब एक पर लगभग उड़ा दिया।

— luser droog

सीडब्ल्यू की पकड़ को नजरअंदाज करें। उन्होंने इसे ठीक कर दिया!

— लूसर ड्रोग

Answer 12

अजगर - 308

import sys;i=sys.argv[1].split();o=[];s=[];a=o.append;b=s.pop;c=s.append
for t in i:
 if t in"+-*/":
  if s!=[]:a(b())
  c(t)
 else:a(t)
if s!=[]:a(b())
for t in o:
 if t=="+":c(b()+b())
 elif t=="-":m=b();c(b()-m)
 elif t=="*":c(b()*b())
 elif t=="/":m=b();c(b()/m)
 else:c(float(t))
print(b())

पठनीय संस्करण:

# Infix expression calc

import sys

# Shunting-yard algorithm
input = sys.argv[1].split()
output = []
stack = []

for tkn in input:
    if tkn in "+-*/":
        while stack != []:
            output.append(stack.pop())
        stack.append(tkn)
    else:
        output.append(tkn)

while stack != []:
    output.append(stack.pop())

# Eval postfix notation
for tkn in output:
    if tkn == "+":
        stack.append(stack.pop() + stack.pop())
    elif tkn == "-":
        tmp = stack.pop()
        stack.append(stack.pop() - tmp)
    elif tkn == "*":
        stack.append(stack.pop() * stack.pop())
    elif tkn == "/":
        tmp = stack.pop()
        stack.append(stack.pop()/tmp)
    else:
        stack.append(float(tkn))

print(stack.pop())

कमांड-लाइन तर्क, मानक आउटपुट पर आउटपुट के रूप में अभिव्यक्ति लेता है।

Answer 13

पोस्टस्क्रिप्ट (340)

/D<</+{add}/-{sub}/*{mul}/ {div}>>def/eval{/P null def{token not{exit}if exch/rem exch def
dup D exch known{/P load null ne{D/P load get exch/P exch def exec}{/P exch def}ifelse}if
rem}loop/P load null ne{D/P load get exec}if}def {(> )print flush{(%lineedit)(r)file
dup bytesavailable string readline pop eval == flush}stopped{quit}if}loop

और थोड़ा अधिक पठनीय:

%!
/oper<</+{add}/-{sub}/*{mul}/ {div}>>def

/eval{
    /op null def
    {
        token not {exit} if
        exch /rem exch def
        dup oper exch known {
            /op load null ne {
                oper /op load get
                exch /op exch def
                exec
            }{
                /op exch def
            } ifelse
        } if
        rem
    } loop
    /op load null ne { oper /op load get exec } if
} def

{
    (> )print flush
    {
    (%lineedit)(r)file
    dup bytesavailable string readline pop
    eval == flush
    } stopped { quit } if
} loop

Answer 14

जावास्क्रिप्ट (208 वर्ण संकुचित)

स्पष्टता के लिए, यह कोड है इससे पहले कि मैंने इसे संकुचित कर दिया ( जेएस-फैडल ):

function math(match, leftDigit, operator, rightDigit, offset, string) {
    var L = parseFloat(leftDigit)
    var R = parseFloat(rightDigit)
    switch (operator)
    {
        case '*': return L*R;
        case '/': return L/R;
        case '+': return L+R;
        case '-': return L-R;
    }
};

str = prompt("Enter some math:", "-2 + 6 / 2 * 8 - 1 / 2.5 - 18").replace(/ /g, "");
var mathRegex = /(\-?\d+\.?\d*)([\*\/\+\-])(\-?\d+\.?\d*)/;
while(mathRegex.test(str)) {
    str = str.replace(mathRegex, math);
}
alert(str)

यहां इसे 208 वर्णों तक सीमित कर दिया गया है ( जेएस-फैडल ):

function m(x,l,o,r){
    L=(f=parseFloat)(l);
    R=f(r);
    return o=='*'?L*R:o=='/'?L/R:o=='+'?L+R:L-R;
};

M=/(\-?\d+\.?\d*)([\*\/\+\-])(\-?\d+\.?\d*)/;
for(s=prompt().replace(/ /g, "");M.test(s);s=s.replace(M,m)){};
alert(s)

चूंकि मैं अर्ध-कॉलनों के साथ लाइनों को समाप्त कर रहा हूं, सभी हटाने योग्य व्हाट्सएप को चरित्र की गिनती के लिए नजरअंदाज कर दिया गया था, लेकिन स्पष्टता के लिए छोड़ दिया गया था।

Answer 15

हास्केल - 124

let p=let f[x]=Just$read x;f(x:o:r)=lookup o[("-",(-)),("+",(+)),("*",(*)),("/",(/))]<*>f r<*>Just(read x)in f.reverse.words

परिणाम Maybeमोनाड में लपेटा जाएगा

λ: p"-2 + 6 / 2 * 8 - 1 / 2.5 - 18"
Just (-12.0)

इसके अलावा इसके आयात की आवश्यकता <*>है Control.Applicative, लेकिन आयात कोड के बाहर किया जा सकता है, इसलिए मुझे आशा है कि इसकी अनुमति है।

Answer 16

सी# (234) (231) (229) (223) (214)

class A{void Main(string[]s){var n=1;var o="";var r=0F;foreach(var t in s){if(n>0){var v=float.Parse(t);if(o=="")r=v;if(o=="+")r+=v;if(o=="-")r-=v;if(o=="*")r*=v;if(o=="/")r/=v;}o=t;n=-n;}System.Console.Write(r);}}

---

class A{
    void Main(string[] s)
    {
      var n = 1;
      var o = "";
      var r = 0F;

      foreach (var t in s)
      {
        if (n > 0)
        {
          var v = float.Parse(t);
          if (o == "") r = v;
          if (o == "+") r += v;
          if (o == "-") r -= v;
          if (o == "*") r *= v;
          if (o == "/") r /= v;
        }
        o = t;
        n = -n;
      }
      System.Console.Write(r);
    }
}

Comments

मुझे '1 + 1' के लिए '0' मिल रहा है। IDEONE

— रोब

@ माइक इनपुट तर्कों के रूप में, स्टडिन नहीं।

— जोहान्स कुह्न

Answer 17

जावास्क्रिप्ट (87 अक्षर)

alert(prompt().split(/ +/).reduce((a,b,i)=>i%2?(o=b,a):o+1-0?a-b*-(o+1):o<'/'?a*b:a/b))

Answer 18

जावा 11, 151 (लंबोदर फंक्शन के रूप में)

s->{float r=0,t;int o=43,q;for(var x:s.split(" ")){if(x.length()>1|(q=x.charAt(0))>47){t=new Float(x);r=o<43?r*t:o<44?r+t:o<46?r-t:r/t;}o=q;}return r;}

लैम्बडा फ़ंक्शन एक स्ट्रिंग इनपुट लेता है और एक फ्लोट आउटपुट करता है।

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

जावा 11, 241 बाइट्स (पूछे गए आई / ओ के साथ पूर्ण कार्यक्रम के रूप में)

interface M{static void main(String[]a){float r=0,t;int o=43,q;for(var x:new java.util.Scanner(System.in).nextLine().split(" ")){if(x.length()>1|(q=x.charAt(0))>47){t=new Float(x);r=o<43?r*t:o<44?r+t:o<46?r-t:r/t;}o=q;}System.out.print(r);}}

पूर्ण कार्यक्रम STDIN के माध्यम से एक स्ट्रिंग-लाइन ले रहा है और STDOUT को आउटपुट करता है।

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

स्पष्टीकरण:

interface M{                  // Class
  static void main(String[]a){//  Mandatory main-method
    float r=0,                //   Result float, starting at 0
          t;                  //   Temp float
    int o=43,                 //   Operator flag, starting at '+'
        q;                    //   Temp operator flag
    for(var x:new java.util.Scanner(System.in)
                              //   Create an STDIN-reader
               .nextLine()    //   Get the user input
               .split(" ")){  //   Split it on spaces, and loop over it:
      if(x.length()>1         //    If the current String length is larger than 1
                              //    (work-around for negative values)
         |(q=x.charAt(0))>47){//    Or the first character is an operator
                              //    (and set `q` to this first character at the same time)
        t=new Float(x);       //     Convert the String to a float, and set it to `t`
        r=                    //     Change `r` to:
          o<43?               //      If `o` is a '*':
            r*t               //       Multiply `r` by `t`
          :o<44?              //      Else-if `o` is a '+':
            r+t               //       Add `r` and `t` together
          :o<46?              //      Else-if `o` is a '-':
            r-t               //       Subtract `t` from `r`
          :                   //      Else (`o` is a '/'):
            r/t;}             //       Divide `r` by `t`
      o=q;}                   //    And at the end of every iteration: set `o` to `q`
    System.out.print(r);}}    //    Print the result `r` to STDOUT

Answer 19

05AB1E , 30 बाइट्स

#ćs2ôívy`…+-*sk©i-ë®>i+ë®<i*ë/

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

#           # Split the (implicit) input-string by spaces
 ć          # Pop the list, and push the remainder and first item separated to the stack
  s         # Swap so the remainder is at the top of the stack
   2ô       # Split it into parts of size 2 (operator + number pairs)
     í      # Reverse each pair so the numbers are before the operators
v           # Loop over each of the pairs:
 y`         #  Push the number and operator separated to the stack
   …+-*     #  Push a string "+-*"
       sk   #  Get the index of the operator in this string
         ©  #  Store this index in the register (without popping)
   i        #  If the index is 1 (the "-"):
    -       #   Subtract the numbers from each other
   ë®>i     #  Else-if the index is 0 (the "+"):
       +    #   Add the numbers together
   ë®<i     #  Else-if the index is 2 (the "*"):
       *    #   Multiply the numbers with each other
   ë        #  Else (the index is -1, so "/"):
    /       #   Divide the numbers from each other
            # (and output the result implicitly)

---

यदि एक evalबिल्डिन को अनुमति दी गई थी, तो यह एक वैकल्पिक दृष्टिकोण ( 16 बाइट्स ) हो सकता है:

#ćs2ôJv…(ÿ)y«}.E

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

#ćs2ô    # Same as above
     J   # Join each operator+number pair together to a single string
v        # Loop over the operator+number strings:
 …(ÿ)    #  Surround the top of the stack in parenthesis
     y«  #  And append the operator+number string
}.E      # After the loop: evaluate the string using a Python-eval

यह बदल जाएगा "-2 + 6 / 2 * 8 - 1 / 2.5 - 18"करने के लिए "((((((-2)+6)/2)*8)-1)/2.5)-18"उपयोग करने से पहले eval(का उपयोग कर निर्मित .Eसीधे ऑपरेटर की पूर्वता देना होगा */से अधिक +-है, इसलिए कोष्ठक के साथ रूपांतरण पहले)।