前缀式计算(前缀表达式)

前缀式计算

时间限制:1000 ms  |  内存限制:65535 KB

难度:3

描述

先说明一下什么是中缀式:

如2+(3+4)*5这种我们最常见的式子就是中缀式。

而把中缀式按运算顺序加上括号就是:(2+((3+4)*5))

然后把运算符写到括号前面就是+(2 *( +(3 4) 5) )

把括号去掉就是:+ 2 * + 3 4 5

最后这个式子就是该表达式的前缀表示。

给你一个前缀表达式,请你计算出该前缀式的值。

比如:

+ 2 * + 3 4 5的值就是 37

输入
有多组测试数据,每组测试数据占一行,任意两个操作符之间,任意两个操作数之间,操作数与操作符之间都有一个空格。输入的两个操作数可能是小数,数据保证输入的数都是正数,并且都小于10,操作数数目不超过500。 以EOF为输入结束的标志。
输出
对每组数据,输出该前缀表达式的值。输出结果保留两位小数。
样例输入
+ 2 * + 3 4 5
+ 5.1 / 3 7
样例输出
37.00
5.53题解:自己写了一大堆代码结果wa了,至今没发现错误,大神就几行就A了;论代码的灵活性;借助大神写的AC:
 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cmath>
 4 #include<algorithm>
 5 #include<cstring>
 6 #include<queue>
 7 #include<stack>
 8 using namespace std;
 9 double f(){
10     char s[10];
11     if(!~scanf("%s",s))exit(0);
12     switch(*s){
13         case ‘+‘:return f()+f();break;
14         case ‘-‘:return f()-f();break;
15         case ‘/‘:return f()/f();break;
16         case ‘*‘:return f()*f();break;
17         default:return atof(s);
18     }
19 }
20 int main(){
21     while(1)printf("%.2lf\n",f());
22     return 0;
23 }

自己的WA:

  1 #include<cstdio>
  2 #include<iostream>
  3 #include<cmath>
  4 #include<algorithm>
  5 #include<cstring>
  6 #include<queue>
  7 #include<stack>
  8 using namespace std;
  9 const int INF=0x3f3f3f3f;
 10 #define mem(x,y) memset(x,y,sizeof(x))
 11 #define SI(x) scanf("%d",&x)
 12 #define PI(x) printf("%d",x)
 13 #define ll root<<1
 14 #define rr root<<1|1
 15 typedef long long LL;
 16 const int MAXN=10010;
 17 char s[MAXN];
 18 char inout(char a,char b){
 19     if(a==‘#‘)return ‘>‘;
 20     if(b==‘=‘)return ‘=‘;
 21     if(a==‘+‘||a==‘-‘){
 22         if(b==‘*‘||b==‘/‘)return ‘>‘;
 23         else return ‘<‘;
 24     }
 25     if(a==‘*‘||a==‘/‘)return ‘<‘;
 26 }
 27 double work(double x,char o,double y){
 28     switch(o){
 29         case ‘+‘:return x+y;break;
 30         case ‘-‘:return x-y;break;
 31         case ‘*‘:return x*y;break;
 32         case ‘/‘:return x/y;break;
 33     }
 34 }
 35 void getnum(int& i,double& num){
 36     double p=10;
 37     while(isdigit(s[i])||s[i]==‘.‘){
 38         if(s[i]==‘.‘){
 39             i++;p=0.1;continue;
 40         }
 41         if(p==10)num=num*10+s[i]-‘0‘;
 42         else num=num+(s[i]-‘0‘)*p,p*=0.1;
 43         i++;
 44     }
 45 }
 46 int main(){
 47     while(gets(s)){
 48         stack<char>s1;
 49         stack<double>s2;
 50         s1.push(‘#‘);
 51         int len=strlen(s);
 52         s[len]=‘=‘;
 53         s[len+1]=‘\0‘;
 54         //puts(s);
 55         int temp=0;
 56         for(int i=0;s[i];){
 57             if(s[i]==‘ ‘){
 58                 i++;continue;
 59             }
 60             double num=0;
 61             if(isdigit(s[i])||s[i]==‘.‘){
 62                 getnum(i,num);
 63                 if(temp)temp++;
 64                 s2.push(num);
 65                 if(temp==3){
 66                     double a=s2.top();
 67                     s2.pop();
 68                     double b=s2.top();
 69                     s2.pop();
 70                     s2.push(work(b,s1.top(),a));
 71                     s1.pop();
 72                     temp=0;
 73                 }
 74             }
 75             else{
 76                 switch(inout(s1.top(),s[i])){
 77                     case ‘<‘:
 78                         s1.push(s[i]);
 79                         i++;
 80                         break;
 81                     case ‘>‘:
 82                         s1.push(s[i]);
 83                         i++;
 84                         temp=1;
 85                         break;
 86                     case ‘=‘:
 87                         double a=s2.top();
 88                         s2.pop();
 89                         double b=s2.top();
 90                         s2.pop();
 91                         s2.push(work(b,s1.top(),a));
 92                         s1.pop();
 93                         break;
 94                 }
 95             }
 96         }
 97         printf("%.2lf\n",s2.top());
 98     }
 99     return 0;
100 }

时间: 2024-07-30 13:39:50

前缀式计算(前缀表达式)的相关文章

NYOJ 128 前缀式计算

前缀式计算 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 先说明一下什么是中缀式: 如2+(3+4)*5这种我们最常见的式子就是中缀式. 而把中缀式按运算顺序加上括号就是:(2+((3+4)*5)) 然后把运算符写到括号前面就是+(2 *( +(3 4) 5) ) 把括号去掉就是:+ 2 * + 3 4 5 最后这个式子就是该表达式的前缀表示. 给你一个前缀表达式,请你计算出该前缀式的值. 比如: + 2 * + 3 4 5的值就是 37 输入 有多组测试数据,每

NYOJ128 前缀式计算 【栈】

前缀式计算 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描写叙述 先说明一下什么是中缀式: 如2+(3+4)*5这样的我们最常见的式子就是中缀式. 而把中缀式按运算顺序加上括号就是:(2+((3+4)*5)) 然后把运算符写到括号前面就是+(2 *( +(3 4) 5) ) 把括号去掉就是:+ 2 * + 3 4 5 最后这个式子就是该表达式的前缀表示. 给你一个前缀表达式,请你计算出该前缀式的值. 比方: + 2 * + 3 4 5的值就是 37 输入 有多组測试数

前缀式计算

前缀式计算 描述 先说明一下什么是中缀式: 如2+(3+4)*5这种我们最常见的式子就是中缀式. 而把中缀式按运算顺序加上括号就是:(2+((3+4)*5)) 然后把运算符写到括号前面就是+(2 *( +(3 4) 5) ) 把括号去掉就是:+ 2 * + 3 4 5 最后这个式子就是该表达式的前缀表示. 给你一个前缀表达式,请你计算出该前缀式的值. 比如: + 2 * + 3 4 5的值就是 37 输入 有多组测试数据,每组测试数据占一行,任意两个操作符之间,任意两个操作数之间,操作数与操作符

NYOJ128前缀式计算

前缀式计算 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 先说明一下什么是中缀式: 如2+(3+4)*5这种我们最常见的式子就是中缀式. 而把中缀式按运算顺序加上括号就是:(2+((3+4)*5)) 然后把运算符写到括号前面就是+(2 *( +(3 4) 5) ) 把括号去掉就是:+ 2 * + 3 4 5 最后这个式子就是该表达式的前缀表示. 给你一个前缀表达式,请你计算出该前缀式的值. 比如: + 2 * + 3 4 5的值就是 37 输入 有多组测试数据,每

NYOJ--128--前缀式计算(表达式求值)

前缀式计算 时间限制:1000 ms  |  内存限制:65535 KB 难度:3 描述 先说明一下什么是中缀式: 如2+(3+4)*5这种我们最常见的式子就是中缀式. 而把中缀式按运算顺序加上括号就是:(2+((3+4)*5)) 然后把运算符写到括号前面就是+(2 *( +(3 4) 5) ) 把括号去掉就是:+ 2 * + 3 4 5 最后这个式子就是该表达式的前缀表示. 给你一个前缀表达式,请你计算出该前缀式的值. 比如: + 2 * + 3 4 5的值就是 37 输入 有多组测试数据,每

NYOJ128 前缀式计算(栈的运用)

题目信息: http://acm.nyist.net/JudgeOnline/problem.php?pid=128 + 2 * + 3 4 5的值就是 37,详见输入输出. 输入 有多组测试数据,每组测试数据占一行,任意两个操作符之间,任意两个操作数之间,操作数与操作符之间都有一个空格.输入的两个操作数可能是小数,数据保证输入的数都是正数,并且都小于10,操作数数目不超过500. 以EOF为输入结束的标志. 输出 对每组数据,输出该前缀表达式的值.输出结果保留两位小数. 样例输入 + 2 *

南阳oj 前缀式计算 题目218

 #include<stdio.h> #include<stdlib.h> #include<string.h> #include<stack> #define N 1000 using namespace std; char s[N],b[3]; stack<double>num; stack<char>st; int main() { while(gets(s)) { int k=strlen(s); double a1,a2

逆波兰式(后缀表达式)的计算

输入 :后缀表达式(可带浮点数) 输出:double型的计算结果 代码: #include <stdio.h> #include <stdlib.h> #include <malloc.h> #define ElemType double #define Stack_Init_Size 100 #define Increase_Size 10 #define MaxBuffer 10 typedef struct sqStack { ElemType *top; Ele

恶补C++ 之 自增、自减操作符前缀式与后缀式的区别

相信很多人刚开始学习编程的时候,也是为这个问题烦恼过吧,前缀式与后缀式,在很久之前,式没有办法区别++和--操作符的前缀和后缀的调用的.不过在C++已经得到了扩展. 然而无论式前缀或者后缀,都只有一个参数.为了解决这个问题,C++规定后缀形式有一个int类型的参数,当函数被调用的时候,编译器传递一个0作为int参数给该函数: class UPInt { public: UPInt& operator++();        // ++前缀 const UPInt operator++(int);