PTA L2-033

L2-033 简单计算器 (25 分)

本题要求你为初学数据结构的小伙伴设计一款简单的利用堆栈执行的计算器。如上图所示，计算器由两个堆栈组成，一个堆栈 S1 存放数字，另一个堆栈 S2 存放运算符。计算器的最下方有一个等号键，每次按下这个键，计算器就执行以下操作：

1. 从 S₁ 中弹出两个数字，顺序为 n₁ 和 n₂
2. 从 S₂ 中弹出一个运算符 op
3. 执行计算 n₂ op n₁
4. 将得到的结果压回 S₁

直到两个堆栈都为空时，计算结束，最后的结果将显示在屏幕上。

输入格式：

输入首先在第一行给出正整数 N（1<N≤103），为 S1 中数字的个数。

第二行给出 N 个绝对值不超过 100 的整数；第三行给出 N−1 个运算符 —— 这里仅考虑 +、-、*、/ 这四种运算。一行中的数字和符号都以空格分隔。

输出格式：

将输入的数字和运算符按给定顺序分别压入堆栈 S1 和 S2，将执行计算的最后结果输出。注意所有的计算都只取结果的整数部分。题目保证计算的中间和最后结果的绝对值都不超过 109。

如果执行除法时出现分母为零的非法操作，则在一行中输出：ERROR: X/0，其中 X 是当时的分子。然后结束程序。

输入样例 1：

5
40 5 8 3 2
/ * - +

输出样例 1：

2

输入样例 2：

5
2 5 8 4 4
* / - +

输出样例 2：

ERROR: 5/0

注意项：

• 所有的计算都只取结果的整数部分。（直接用整型舍弃小数部分）
• 题目保证计算的中间和最后结果的绝对值都不超过10⁹。（不会爆int）
• 如果执行除法时出现分母为零的非法操作，则在一行中输出：ERROR: X/0，其中 X 是当时的分子。然后结束程序。

S1	S2
2
3	+
8	-
5	*
40	/

1. 从 S₁ 中弹出两个数字，顺序为 n₁ 和 n₂
   $$\begin{gathered} n_1=2 \\ {n}_2=3 \end{gathered}$$
2. 从 S₂ 中弹出一个运算符 op
   $$op=+$$
3. 执行计算 n₂ op n₁
   $$\begin{array}{rl}{S}_1& =n_{2}op{n}_1\\ & =3+2\\ & =5\end{array}$$
4. 将得到的结果压回 S₁

S1	S2
5
8	-
5	*
40	/

1. 从 S₁ 中弹出两个数字，顺序为 n₁ 和 n₂
   $$\begin{gathered} n_1=5 \\ {n}_2=8 \end{gathered}$$
2. 从 S₂ 中弹出一个运算符 op
   $$op=-$$
3. 执行计算 n₂ op n₁

$$\begin{array}{rl}{S}_1& =n_{2}op{n}_1\\ & =8-5\\ & =3\end{array}$$

4. 将得到的结果压回 S₁

S1	S2
3
5	*
40	/

1. 从 S₁ 中弹出两个数字，顺序为 n₁ 和 n₂
   $$\begin{gathered} n_1=3 \\ {n}_2=5 \end{gathered}$$
2. 从 S₂ 中弹出一个运算符 op
   $$op=\ast$$
3. 执行计算 n₂ op n₁
   $$\begin{array}{rl}{S}_1& =n_{2}op{n}_1\\ & =5\ast 3\\ & =15\end{array}$$
4. 将得到的结果压回 S₁

S1	S2
15
40	/

1. 从 S₁ 中弹出两个数字，顺序为 n₁ 和 n₂
   $$\begin{gathered} n_1=15 \\ {n}_2=40 \end{gathered}$$
2. 从 S₂ 中弹出一个运算符 op
   $$op=/$$
3. 执行计算 n₂ op n₁
   $$\begin{array}{rl}{S}_1& =n_{2}op{n}_1\\ & =40\ast 15\\ & =2\end{array}$$

c++程序

#include <map>
#include <stack>
#include <queue>
#include <math.h>
#include <vector>
#include <cstdio>
#include <string>
#include <cstring>
#include <sstream>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int INF = 0x3f3f3f3f;
const int dir[4][2] = { {1,0} ,{-1,0},{0,1},{0,-1} };
int main()
{
    int n;
    stack<int> a;
    stack<char> b;

    cin >> n;

    for (int i = 0; i < n; i++)
    {
        int t;

        cin >> t;
        a.push(t);
    }

    for (int i = 0; i < n - 1; i++) {
        char t;

        cin >> t;
        b.push(t);
    }


    while (!b.empty()) {
        int n1 = a.top();
        a.pop();
        int n2 = a.top();
        a.pop();

        char op = b.top();
        b.pop();

        if (op == '/' && n1 == 0) {
            cout << "ERROR: " << n2 << "/0";
            return 0;
        }

        if (op == '+') {
            a.push(n2 + n1);
        }
        if (op == '-') {
            a.push(n2 - n1);
        }
        if (op == '*') {
            a.push(n2 * n1);
        }
        if (op == '/') {
            a.push(n2 / n1);
        }

    }
    
    cout << a.top();

    return 0;
}
/*

*/