คุณต้องเขียนโปรแกรมเพื่อประเมินสตริงที่จะถูกป้อนลงในเครื่องคิดเลข

โปรแกรมจะต้องยอมรับอินพุตและเอาต์พุตคำตอบที่ถูกต้อง สำหรับภาษาที่ไม่ได้มีฟังก์ชั่นอินพุต / เอาต์พุตมาตรฐานคุณอาจคิดฟังก์ชั่นและreadLineprint

ความต้องการ

• ห้ามใช้ฟังก์ชั่น "eval" ใด ๆ
• สามารถจัดการกับจำนวนจุดลอยตัวและจำนวนลบ
• รองรับอย่างน้อยที่สุดเครื่องหมาย +, -, *, และ /
• สามารถจัดการกับการป้อนข้อมูลที่มีหนึ่งหรือมากกว่าช่องว่างระหว่างผู้ประกอบการและตัวเลข
• หาค่าของนิพจน์จากซ้ายไปขวา

โปรแกรมที่สั้นที่สุดชนะ ในกรณีที่เสมอโปรแกรมที่ถูกส่งมาก่อนชนะ

คุณสามารถสันนิษฐานได้ว่าอินพุตนั้นถูกต้องและเป็นไปตามรูปแบบที่ถูกต้อง

กรณีทดสอบ

อินพุต

-4 + 5

เอาท์พุต

1

-7.5 / 2.5

เอาท์พุต

-3

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

เอาท์พุต

-12

Ruby - 74 69 67 65 ตัวอักษร

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

Befunge - 37 x 5 = 185 38 x 3 = 114 ตัวอักษร

นี่คือ จำกัด จำนวนเต็มเนื่องจาก Befunge ไม่มีการสนับสนุนจุดลอย

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

คำอธิบาย

คุณสมบัติที่โดดเด่นที่สุดของBefungeคือแทนที่จะเป็นชุดคำสั่งเชิงเส้นเหมือนภาษาส่วนใหญ่ มันเป็นตาราง 2d ของคำแนะนำตัวอักษรเดียวซึ่งการควบคุมสามารถไหลได้ในทุกทิศทาง

วิธีแรก&เพียงแค่ใส่หมายเลขแรก vและ>การควบคุมแล้วเปลี่ยนเส้นทางไปยังเส้นทางหลักในแถวที่สอง

~:0`!#v_

อินพุตนี้ใส่อักขระ ( ~) ทำซ้ำ ( :) ดันศูนย์ลงบนสแต็ก ( 0) ดึงองค์ประกอบสองอันดับแรกและพิจารณาว่าตัวที่สองนั้นใหญ่กว่าตัวแรกหรือไม่ ( ` ฉันประหลาดใจที่คุณไม่สามารถใช้ `` `เพื่อรับ โค้ด backticks. ) กลับค่าความจริงขององค์ประกอบด้านบน ( !) จากนั้นไปทางขวาหากเป็นศูนย์ลดลงอย่างอื่น ( #v_)

โดยพื้นฐานแล้วมันกำลังตรวจสอบว่าอินพุต-1แสดงถึงอินพุตอีกต่อไปหรือไม่

># $ .# @

หากอินพุตเป็น-1ค่าอินพุตที่ซ้ำกันจะถูกทิ้ง ( $) ด้านบนของสแต็กจะถูกส่งออกเป็นจำนวนเต็ม ( .) และโปรแกรมหยุดทำงาน ( @)

:" "`! #v_

มิฉะนั้นกระบวนการที่คล้ายกันจะถูกทำซ้ำเพื่อตรวจสอบว่าอินพุตมีค่าน้อยกว่าหรือเท่ากับช่องว่าง ถ้ามันเป็นช่องว่างการควบคุมก็จะลดลงมิฉะนั้นควบคุมหัวขวา

^      ># $ .# @#<

หากเป็นช่องว่างแสดงว่ามีการเปลี่ยนเส้นทางไปทางซ้าย ( <); โปรแกรมหยุด ( @), output ( .) และการเปลี่ยนเส้นทางขวา ( >) ถูกข้ามโดยใช้#; แต่การกำจัดจะดำเนินการเพื่อลบพื้นที่ออกจากสแต็ก ในที่สุดมันจะถูกเปลี่ยนเส้นทางเพื่อเริ่มต้นการดำเนินการถัดไป ( ^)

:","`#^_

หากไม่ใช่พื้นที่กระบวนการเดียวกันจะใช้ในการแยกถ้ามันอยู่ใน[+, *]หรือ[-, \]ไปทางขวาและขึ้นตามลำดับ

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

สำหรับ[+, *]มันถูกแบ่งออกอีกครั้งเพื่อตรวจสอบไม่ว่าจะเป็นหรือ+ *หาก+ถูกนำไปยังหมายเลขถัดไปคืออินพุต ( &) และถูกเพิ่ม ( +) การควบคุมจะล้อมรอบและถูกเปลี่ยนเส้นทางไปยังเส้นทางหลักสำหรับอักขระถัดไป หากเป็นเช่น*นั้นอินพุต ( &) และทวีคูณ ( *) จากนั้นจะล้อมรอบโดยตรง

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

สำหรับการ[-, \]ที่จะเริ่มต้นด้านซ้ายหัวขวา #'s ข้ามตัวละครหลังจากที่พวกเขาเพื่อให้เส้นทางที่เริ่มต้น"-"`_ซึ่งก็กำหนดว่ามันเป็นหรือ- /หากเป็นเช่น/นั้นระบบจะปล่อยให้อินพุต ( &) และหาร ( /) ต่อไป หากเป็นเช่น-นั้นหัวจะถูกต้องให้ข้ามอักขระอีกครั้งเพื่อดำเนินการ&"-"$-ส่งผลให้มีการป้อนตัวเลข ( &) -อักขระที่ถูกผลักลงบนสแต็กแล้วละทิ้ง ( "-"$) จากนั้นจึงลบการคำนวณ ( -) การควบคุมจะถูกเปลี่ยนเส้นทางกลับไปยังเส้นทางหลัก

Python 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)

ลำดับความสำคัญของการดำเนินการจากซ้ายไปขวา

Python (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]

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);}

Tcl 8.6, 57 48 ตัวอักษร

• อินพุตจากอาร์กิวเมนต์:

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

• จาก Stdin ( 64 53 )

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

คุณต้องใช้เชลล์เชิงโต้ตอบสำหรับทั้งสองวิธี

ผมปฏิบัติอินพุตเป็นรายการ (Tcl ใช้พื้นที่เป็นตัวคั่น) ใช้องค์ประกอบแรกและกำหนดให้aแล้วฉันเดินผ่านส่วนที่เหลือเอา 2 องค์ประกอบแต่ละครั้งผู้ประกอบการและจำนวนที่สองใช้ประกอบการใน$aและ$bและกำหนด aส่งผลให้ aในตอนท้ายผลที่ได้คือใน

Haskell: 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

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

C ++ 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;
}

Perl (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

PostScript (145)

อีกรายการ PostScript (ขอบคุณ luser droog สำหรับการขุดสนามกอล์ฟที่น่าสนใจสำหรับ PostScript!):

[/+{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
=

ยกเลิกแข็งแรงเล่นกอล์ฟ:

[/+{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
=

Python - 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())

รับนิพจน์เป็นอาร์กิวเมนต์บรรทัดคำสั่งเอาต์พุตบนเอาต์พุตมาตรฐาน

Postscript (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

JavaScript (บีบอัด 208 อักขระ)

เพื่อความชัดเจนนี่เป็นรหัสก่อนที่ฉันจะย่อขนาดลง ( JS-Fiddle of it ):

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 อักขระ ( JS-Fiddle of it ):

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)

ตั้งแต่ฉันสิ้นสุดบรรทัดด้วยเซมิโคลอนช่องว่างที่ถอดออกได้ทั้งหมดถูกละเว้นสำหรับการนับตัวอักษร แต่ทิ้งไว้เพื่อความชัดเจน

Haskell - 124

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

ผลลัพธ์จะถูกห่อด้วยMaybemonad

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

นอกจากนี้ยังต้องนำเข้า<*>จากControl.Applicativeแต่การนำเข้าสามารถทำได้นอกรหัสดังนั้นฉันหวังว่ามันจะได้รับอนุญาต

ค# (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);
    }
}

JavaScript (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))

Java 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;}

ฟังก์ชั่นแลมบ์ดาจะทำการป้อนข้อมูลสตริงและส่งทุ่น

ลองออนไลน์

Java 11, 241 ไบต์ (เป็นโปรแกรมเต็มรูปแบบด้วย I / O ที่ถาม)

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);}}

โปรแกรมเต็มรูปแบบรับสาย String ผ่าน 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

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"ก่อนที่จะใช้evalbuiltin (การใช้.Eโดยตรงจะให้ความสำคัญกับโอเปอเรเตอร์*/มากกว่า+-ดังนั้นการแปลงด้วยวงเล็บจะเป็นอันดับแรก)