Basic Calculator

Question

You must write a program to evaluate a string that would be entered into a calculator.

The program must accept input and output the correct answer. For languages that do not have standard input/output functions, you may assume the functions readLine and print.

Requirements

• Does not use any kind of "eval" functions
• Can handle floating point and negative numbers
• Supports at least the +, -, *, and / operators
• Can handle input containing one or more spaces between the operators and numbers
• Evaluates the expression from left to right

The program that is the shortest wins. In the event of a tie, the program that was submitted first wins.

You can assume that the input is valid and follows the correct format

Test Cases

Input

-4 + 5

Output

1

---

Input

-7.5 / 2.5

Output

-3

---

Input

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

Output

-12

Answer 1

Ruby - 74 69 67 65 characters

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

Answer 2

Befunge - 37 x 5 = 185 38 x 3 = 114 characters

This is limited to integer numbers as Befunge has no floating point support.

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

Explanation

The biggest distinguishing feature of Befunge is that instead of being a linear set of instructions like most languages; it is a 2d grid of single character instructions, where control can flow in any direction.

The first & simply inputs the first number. The v and > then redirect control to the main path on the second row.

~:0`!#v_

This inputs a character (~), duplicates it (:), pushes zero onto the stack (0), pops the top two elements and determines if the second is greater than the first (` I'm surprised you can't use ``` to get code backticks.), inverts the truthiness of the top element (!), then goes right if it is zero, down otherwise (#v_).

Basically it's checking whether the input is -1 representing no more input.

># $ .# @

If the input was -1 then the duplicated input value is discarded ($), the top of the stack is output as an integer (.) and the program is halted (@).

:" "`! #v_

Otherwise a similar process is repeated to determine if the input is less than or equal to a space. If it is a space then control goes down, otherwise control heads right.

^      ># $ .# @#<

If it is a space then it's redirected left (<); the program halt (@), output (.) and right redirection (>) are all skipped using #; but the discard is executed to remove the space from the stack. Finally it's redirected up to begin the next execution (^).

:","`#^_

If it wasn't a space the same process is used to split on if it is in [+, *] or in [-, \] going right and up respectively.

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

For [+, *] it is again split to determine whether it is a + or a *. If + it is directed down then the next number is input (&) and they are added (+), the control then wraps around and is redirected up to the main path for the next character. If * then it inputs (&) and multiplies (*) then directly wraps around.

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

For [-, \] it starts on the right heading left. The #'s skip the character after them so the initial path is "-"`_ which simply determines if it is - or /. If it is / then it continues left to input (&) and divide (/). If it is - then it heads right, again skipping characters so that it executes &"-"$- resulting in the number being input (&) the - character being pushed onto the stack then discarded ("-"$) and then the subtraction being calculated (-). The control is then redirected back to the main path.

Answer 3

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]

Answer 4

C - 168 126 characters

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 5

Python 3 (105)

Manages the four basic operations, but it only costs 5 characters each to add ^ or %.

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)

Presedense of operations is left to right.

Answer 6

C++0x 205 203 198 194 chars

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

Nicely formatted:

#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 7

Perl (97)

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

read from arguments

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

read from input

@_=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 8

C# (234) (231) (229) (223)

class A{static void Main (string[]s){var n=true;var o="";var r=0F;foreach(var t in s){if(n){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{
    static void Main (string[]s){
        var n=true;
        var o="";
        var r=0F;

        foreach(var t in s)
        {
            if(n){
                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);
    }
}

Answer 9

PostScript (145)

Another PostScript entry (thanks to luser droog for digging the golfs interesting for 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
=

Un-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
=

Answer 10

C: 111 108 characters

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

It fulfills all the requirements, usage:

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

Answer 11

Tcl 8.6, 57 chars.

• Input from arguments:

  lmap o\ b [lassign $argv a] {set a [expr $a$o$b]};puts $a
  

• From Stdin (64)

  lmap o\ b [lassign [gets stdin] a] {set a [expr $a$o$b]};puts $a
  

Answer 12

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

And a little more readable:

%!
/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 13

Haskell: 124 114 characters

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

A rather straight-forward answer, using pattern matching and a simple case statement for the heavy lifting. Usage:

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