Calculatrice avancée

28

Vous devez écrire un programme qui évalue une chaîne qui serait entrée dans une calculatrice avancée.

Le programme doit accepter la saisie à l'aide de stdin et produire la bonne réponse. Pour les langues qui n'ont pas de fonctions pour accepter stdin, vous pouvez assumer les fonctions readLineet printgérer ces tâches.

Exigences:

  • N'utilise aucun type de fonctions "eval"
  • Peut gérer les nombres à virgule flottante et négatifs
  • Prend en charge au moins les opérateurs +, -, *, / et ^
  • Prend en charge les crochets et les parenthèses pour remplacer l'ordre normal
  • Peut gérer une entrée contenant un ou plusieurs espaces entre les opérateurs et les nombres
  • Évalue l'entrée en utilisant l' ordre standard des opérations

Cas de test

Contribution

10 - 3 + 2

Sortie

9


Contribution

8 + 6 / 3 - 7 + -5 / 2.5

Sortie

1


Contribution

4 + [ ( -3 + 5 ) * 3.5 ] ^ 2 - 12

Sortie

41
Kevin Brown
la source
1
Est-ce correct si les nombres sortis ont une fin .0à la fin s'ils sont des entiers? Aussi: quelle doit être la précision de la calculatrice (en ce qui concerne la précision en virgule flottante et autres)?
sepp2k
1
La sortie peut avoir une fin .0à la fin. Je ne suis pas trop sûr de la précision, mais plus c'est mieux.
Kevin Brown
1
La version Stack Overflow était un évaluateur d'expression mathématique (PEMDAS complet) . Bien que beaucoup de réponses à celle-ci soient des lignes de comptage (?!?). Il y a toujours plusieurs réponses compactes en c.
dmckee
Bonus pour les calculateurs PN / RPN?
Mateen Ulhaq

Réponses:

8

C ++, 640 583

string k="[]()+-*/^";stack<double> m;stack<char> n;
#define C(o,x,y) ('^'==o?x<y:x<=y)
#define Q(a) double a=m.top();m.pop();
#define R(o) {Q(b)Q(a)m.push(o=='+'?a+b:o=='-'?a-b:o=='*'?a*b:o=='/'?a/b:o=='^'?pow(a,b):0);n.pop();}
while(!cin.eof()){string s;getline(cin,s,' ');if(s.empty())continue;if('\n'==*--s.end())s.erase(--s.end());(s.size()==1&&s.npos!=k.find(s[0]))?({char c=s[0]=='['?'(':s[0]==']'?')':s[0];while(!n.empty()&&'('!= c&&C(c,k.find(c),k.find(n.top())))R(n.top());')'==c?n.pop():n.push(c);}):m.push(strtod(s.c_str(),0));}while(!n.empty())R(n.top());cout<<m.top()<<endl;

Dentelé

string k="[]()+-*/^";
stack<double> m;
stack<char> n;
#define C(o,x,y) ('^'==o?x<y:x<=y)
#define Q(a) double a=m.top();m.pop();
#define R(o) {Q(b)Q(a)m.push(o=='+'?a+b:o=='-'?a-b:o=='*'?a*b:o=='/'?a/b:o=='^'?pow(a,b):0);n.pop();}
while(!cin.eof())
{
    string s;
    getline(cin,s,' ');
    if(s.empty())continue;
    if('\n'==*--s.end())s.erase(--s.end());
    (s.size()==1&&s.npos!=k.find(s[0]))?({
        char c=s[0]=='['?'(':s[0]==']'?')':s[0];
        while(!n.empty()&&'('!= c&&C(c,k.find(c),k.find(n.top())))
            R(n.top());
        ')'==c?n.pop():n.push(c);
    }):m.push(strtod(s.c_str(),0));
}
while(!n.empty())
    R(n.top());
cout<<m.top()<<endl;

Mon premier golf de code, donc avec impatience les commentaires et les critiques!

drspod
la source
Gère l'associativité droite de l'opérateur d'exponentiation, ce que la solution Perl de JB ne semble pas.
drspod
Ni l'énoncé du problème ni la page wikipedia liée mentionnant l'exponentiation ne doivent être associatifs à droite. De plus, la page wikipedia indique explicitement que les deux façons se trouvent sur les calculatrices commerciales.
JB
1
+1 joliment joué, mais ... simplement supprimer les inclusions, using namespace stdet une fonction principale n'est pas vraiment ok, n'est-ce pas?
cessé de tourner dans
2

PHP - 394 354 312 caractères

<?=e(!$s=preg_split('#\s+#',`cat`,-1,1),$s);function e($P,&$s){$S='array_shift';if(($a=$S($s))=='('|$a=='['){$a=e(0,$s);$S($s);}while($s&&($p=strpos(' +-*/^',$o=$s[0]))&&$p>=$P){$b=e($p+($S($s)!='^'),$s);if($o=='+')$a+=$b;if($o=='-')$a-=$b;if($o=='*')$a*=$b;if($o=='/')$a/=$b;if($o=='^')$a=pow($a,$b);}return$a;}

Dentelé:

<?
preg_match_all('#\d+(\.\d+)?|\S#',`cat`,$m);
$s=$m[0];
function e($P) {
        global $s;
        if (strpos(" ([",$s[0])){
                array_shift($s);
                $a=e(0);
                array_shift($s);
        } else {
                $a=array_shift($s);
                if ($a=='-')$a.=array_shift($s);
        }
        while ($s && ($p=strpos(' +-*/^',$o=$s[0])) && $p >= $P) {
                array_shift($s);
                $b = e($p+($o!='^'));
                switch($o){
                case'+':$a+=$b;break;
                case'-':$a-=$b;break;
                case'*':$a*=$b;break;
                case'/':$a/=$b;break;
                case'^':$a=pow($a,$b);
                }
        }
        return $a;
}
echo e(0);
Arnaud Le Blanc
la source
2

Postscript, 446

Cela utilise l'algorithme de triage.

[/*[/p
2/e{mul}>>/d[/p
2/e{div}>>/+[/p
1/e{add}>>/-[/p
1/e{sub}>>/o[/p
9/e{}>>/c[/p
-1/e{}>>/^[/p
3/e{exp}>>/p
0>>begin/s(%stdin)(r)file 999 string readline pop def
0 1 s length 1 sub{s exch[0 1 255{}for]dup[(\(o)([o)(\)c)(]c)(/d)]{{}forall
put dup}forall
pop
3 copy pop
get
get
put}for{s token not{exit}if
exch/s exch store{cvr}stopped{load
dup/p get
p
le{currentdict end
exch begin/e get exec}{begin}ifelse}if}loop{{e end}stopped{exit}if}loop
=

Non golfé et commenté:

% We associate the operators with their precedence /p and the executed commend /e
[
  (*)[/p  2 /e{mul}>>
  (d)[/p  2 /e{div}>> % This is division
  (+)[/p  1 /e{add}>>
  (-)[/p  1 /e{sub}>>
  (o)[/p  9 /e{   }>> % This is open bracket
  (c)[/p -1 /e{   }>> % This is close bracket
  (^)[/p  3 /e{exp}>>
  /p 0
>>begin

% Let's read the input string
/s(%stdin)(r)file 999 string readline pop def

% If we want to use the token operator, we have to replace (, [, ), ] and / to get meaningful results
% We use kind of an encoding array (familiar to PostScripters) to map those codes to o, c, and d.
0 1 s length 1 sub{        % index
  s exch                   % string index
  [0 1 255{}for] dup       % string index translationArray translationArray
  [(\(o)  ([o)  (\)c)  (]c)  (/d)] % string index translationArray translationArray reencodeArray
  {                        % string index translationArray translationArray translationString
    {}forall               % string index translationArray translationArray charCode newCharCode
    put dup                % string index translationArray translationArray
  }forall                  % string index translationArray translationArray
  pop                      % string index translationArray
  3 copy pop               % string index translationArray string index
  get                      % string index translationArray charCode
  get                      % string index translatedCharCode
  put                      % -/-
}for

% Now we can actually start interpreting the string
% We use the stack for storing numbers we read and the dictionary stack for operators that are "waiting"
{                          % number*
  s token not{exit}if      % number* string token
  exch /s exch store       % number* token
  % We try to interpret the token as a number
  {cvr}stopped{            % number* token
    % If interpretation as number fails, we have an operator
    load                   % number* opDict
    % Compare operator precedence with last operator on dictstack
    dup /p get             % number* opDict opPrec
    p                      % number* opDict opPrec prevOpPrec
    le {                   % number* opDict
      % If the last operator on the stack has at least the same precedence, execute it
      currentdict end      % number* opDict prevOpDict
      exch begin           % number* prevOpDict
      /e get exec          % number*
    }{                     % number* opDict
      % If last operator doesn't have higher precedence, put the new operator on the dictstack as well
      begin
    }ifelse
  }if
}loop
% If we're finished with interpreting the string, execute all operators that are left on the dictstack
{{e end}stopped{exit}if}loop
=

TODO : Associativité à droite de l'exponentation

Thomas W.
la source
Ah ... Le dictstack: génial!
luser droog
Je suis autorisé à commenter stackoverflow, donc j'étais un peu confus. Est-il normal que la réputation soit gérée séparément, ou ai-je bousillé mes identifiants?
Thomas
Je voulais vous dire qu'il doit y avoir un problème avec votre solution car les trois cas de test indiqués ci-dessus échouent. Cependant, je n'ai pas encore essayé de comprendre ce que vous faites (certains commentaires seraient cool ;-)).
Thomas W.
1) Une fois que vous avez atteint 200 sur n'importe quel site, vous commencerez à 101 sur chaque site. Ou frappez 50 ici. 2) AUGHH! Je pensais que c'était une extension rapide de la calculatrice de base. Je n'ai même pas vu que les supports sont nécessaires! Et je ne l'ai pas très bien testé. Tant pis; pantalon baissé, au moins mes sous-vêtements sont propres!
luser droog
@luserdroog: "@ThomasW" ne m'invite pas à commenter.
Thomas W.19
1

Python 2 , 339 335 octets

import re
x,s=input(),re.sub
def f(y):
 y,r=s('- ','+ -',y).split(),['^','*','/','+','-']
 for c in r:
  while c in y:d=y.index(c)-1;a,b=map(float,[y[d],y[d+2]]);y=y[:d]+[((a,-a)[a<0]**b,a*b,a/b,a+b,a-b)[r.index(c)]]+y[d+3:]
 return`y[0]`
w=lambda b:s("[([]+[\d+\-*/^ .]*[)\]]",lambda m:f(m.group()[1:]),s(' +',' ',b))
print f(w(w(x)))

Essayez-le en ligne!

  • -4 octets en changeant str (x) avec des guillemets ``!
Keerthana Prabhakaran
la source
0

Postscript, 1000 695 665 494

J'ai volé des idées à ThomasW. Fonctionnalité ajoutée: accepte les chaînes avec ou sans espaces autour des opérateurs.[fonctionnalité supprimée]


L'utilisation ARGUMENTSest plus courte %stdinet plus facile à tester pour démarrer!


Simplification de la substitution pour remplacer simplement les parenthèses par des parenthèses.

575(1)10:36 PM:ps 0> gsnd -q -- calc2bg.ps '10 - 3 + 2'
9
576(1)10:37 PM:ps 0> gsnd -q -- calc2bg.ps '8 + 6 / 3 - 7 + -5 / 2.5'
1.0
577(1)10:37 PM:ps 0> gsnd -q -- calc2bg.ps '4 + [ ( -3 + 5 ) * 3.5 ] ^ 2 - 12'
41.0

Code:

/T[/^[/C{exp}/P 4/X{le}>>/*[/C{mul}/P 3/X{lt}>>/[/C{div}/P
3/X{lt}>>/+[/C{add}/P 2/X{lt}>>/-[/C{sub}/P
2/X{lt}>>>>def[/integertype{}/realtype{}/stringtype{V}/nametype{cvlit/N
exch store{P T N get dup/P get exch/X get exec{exit}if C end}loop T N get
begin}91 40 93 41>>begin/V{0 1 2 index length 1 sub{2 copy get
dup where{exch get}if 3 copy put pop pop}for[/N 0/R 0/P 0/C{}>>begin{token
not{exit}if exch/R exch store dup type exec R}loop{P 0 eq{end exit}if C
end}loop}def ARGUMENTS{V ==}forall

Non golfé et commenté:

%!
%Shunting-Yard Algorithm using dictstack for operators
%invoke with %gsnd -q -- calc2bg.ps [ 'expr1' ]*

%The operator table. C:code P:precedence X:test(implements associativity)
/T[
    /^[/C{exp}/P 4/X{le}>>
    /*[/C{mul}/P 3/X{lt}>>
    /[/C{div}/P 3/X{lt}>>
    /+[/C{add}/P 2/X{lt}>>
    /-[/C{sub}/P 2/X{lt}>>
>>def

%The type-dispatch dictionary
%numbers: do nothing
%string: recurse
%name: process op
[%/integertype{}/realtype{} %now uses `where` below
/stringtype{V}/nametype{
pstack()=
    cvlit/N exch store %stash cur-op
    {
        P %prec(tos)
        T N get %prec(tos) cur-op-dict
        dup/P get %prec(tos) cur-op-dict prec(cur-op)
        exch/X get %prec(tos) prec(cur-op) test(cur-op)
        exec{exit}if %exit if prec(tos) < || <= prec(cur-op)
/C load ==
        C %pop-and-apply
        end
pstack()=
    } loop
    T N get begin %push cur-op
}>>begin

%substitutions
[91 40 93 41>>begin %replace brackets with parens
/V {
    %pre-process
    0 1 2 index length 1 sub {
        2 copy get
        dup where { exch get } if
        3 copy put pop pop
    } for
dup ==

    [/N 0/R 0/P 0/C{}>>begin %dummy base operator and storage
    { token not{exit}if exch /R exch store %extract token, stash Remainder
pstack(>)=
        %dispatch type procedure
        dup type dup where { pop exec }{ pop } ifelse
    R }loop
pstack()=
    {
        P 0 eq{end exit}if %hit dummy op: exit
/C load ==
        C end %pop and apply
    } loop
} def

ARGUMENTS{V ==}forall %iterate through the command-line arguments
luser droog
la source
@ThomasW Je me demande si cela fonctionne pour vous inviter à commenter. (?)
luser droog
J'ai publié une implémentation plus complète de la même idée dans comp.lang.postscript .
luser droog