四则运算 3

老师提出了新的要求

1.学生写的程序必须能判定用户的输入答案是否正确

2.程序必须能处理四种运算的混合算式

要求两人合作分析，单独编程，单独撰写博客

团队成员：苗堃、罗毅（http://www.cnblogs.com/ly199553/） 

设计思路：

查阅了相关资料，发现小学四则运算含有括号数量不多，于是结组讨论时选取了较为简单的我的程序，将数组全部转化为字符串形式，

利用栈实现中缀表达式转换为后缀表达式，转换原则为

1.当读到一个操作数时，立即将它放到输出中。操作符则不立即输出，放入栈中。遇到左圆括号也推入栈中。

2.如果遇到一个右括号，那么就将栈元素弹出，将符号写出直到遇到一个对应的左括号。但是这个左括号只被弹出，并不输出。

3.在读到操作符时，如果此时栈顶操作符优先性大于或等于此操作符，弹出栈顶操作符直到发现优先级更低的元素位置。除了处理')'

的时候，否则决不从栈中移走'('。操作符中，'+' '-'优先级最低，'(' ')'优先级最高。

4.如果读到输入的末尾，将栈元素弹出直到该栈变成空栈，将符号写到输出中。

两位数的字符串传递时加入字符@来区分（http://www.cnblogs.com/ly199553/p/5292391.html）

输入答案后与正确答案进行比较判断对错

#include<stack>
#include<iostream>
#include<deque>
#include<string>
#include<sstream>
#include<time.h>
using namespace std;

int  Num[100];    //将数字存入数组a
string op_arrays[100];    //将运算符存入数组b
string  All[100];    //合成总数组e
string fu[100];      //辅助数组
int true_num = 0;     //统计做对的题目数
int false_num = 0;    //统计做错的题目数

bool isPra(char);    //判断是否为括号
int getPri(char);    //获得符号优先性
void check(char c, stack<char>& coll2, deque<char>& coll3);//判断符号优先性
void allocate(deque<char>& coll1, stack<char>& coll2, deque<char>& coll3);  //将中缀表达式分解为符号和运算数
void calculate(deque<char>& coll3, stack<double>& coll4);  //计算后缀表达式

int main()
{
    srand((int)time(NULL));//设置随机种子，使得程序每次运行的结果都不同
    int subject_number;    //出题数量
    int random_number = 0;    //运算数字字数
    int operation_character = 0;
    int fuhao = 0;    //判定运算符

    int Jude_has_brackets;       //定义左、右括号的是否存在的随机变量
    string left;    //左括号变量
    string right;    //左括号变量
    string sign = "a";   //定义符号变量
    char Jude_has_mul_dev;   //定义是否需要乘除法的变量

    deque<char> coll0;  //消除中缀表达式的空格
    deque<char> coll1;  //盛放中缀表达式
    stack<char> coll2;  //盛放操作符
    deque<char> coll3;    //盛放后缀表达式
    stack<double>coll4;    //计算后缀表达式的辅助容器

    int min, Max;    //定义输入的值得范围的最值(仅能输入整数<=30)
    string w = " ";

    //写一个简易菜单
    cout << "欢       ／￣＼＿／￣＼ "<<endl;
    cout << "迎     　▏     ▔▔▔▔＼    " << endl;
    cout << "使     ／＼　／　　　　　　﹨" << endl;
    cout << "用   ∕　　　　　　　／　　　）" << endl;
    cout << "小   ▏　　　　　　　　●　　▏"<<endl;
    cout << "天   ▏　　　　　　　　　　　▔█ " << endl;
    cout << "才  ◢██◣　　　　　　／＼＿＿／" << endl;
    cout << "四   █████◣　　　　　　　／" << endl;
    cout << "则   █████████████◣ " << endl;
    cout << "运 ◢██████████████▆▄" << endl;
    cout << "算  █◤◢██◣◥█████████◤＼" << endl;
    cout << "自 ◥◢████　████████◤　　 ＼" << endl;
    cout << "助   █████　██████◤　　　　　 ﹨" << endl;
    cout << "系  │　　　│█████◤　　　　　　　　▏" << endl;
    cout << "统  │　　　│　　　　　　　　　　　　▏" << endl;
    cout << "   ∕　　　∕　　　　／▔▔▔＼　　　　 ∕" << endl;
    cout << "  ∕＿＿_／﹨　　　∕　　　　　 ＼　　／＼" << endl;
    cout << "           ＼ 　　 ＼_　　　　　﹨／　　﹨" << endl;
    cout << "             ＼＿＿＿＼　　　　 ﹨／▔＼﹨／▔＼" << endl;
    cout << "                      ＼　　 ∕" << endl;
        cout << "1.请输入产生数字的范围（最小和最大）：";
        cin >> min >> Max;
        cout << "提示：若您需要做乘除法 请不要做超过30以外的乘除法" << endl;
        cout << endl;
        cout << "2.是否需要乘除法[y为需要乘除法 n为不需要乘除法] ";
        cin >> Jude_has_mul_dev;
        while (min<0)
        {
        cout << "请做正数运算：" << endl;
        cout << "输入最小值" << endl;
        cin >> min;
         }
    while (Max>30 && Jude_has_mul_dev == 'y')
    {
        cout << "请重新输入最大值:" << endl;
        cin >> Max;
    }
    cout << "请输入出题数量：";
    cin >> subject_number;

    int i = 0, j, k;
    if ('y' == Jude_has_mul_dev)
    {
        random_number = rand() % 9 + 2;    //随机生成2~10个数
        for (j = 0; j < subject_number; j++)    //设置题目数量
        {
            //清除数组元素
            memset(Num, 0, sizeof(Num));    
            memset(op_arrays, 0, sizeof(op_arrays));    
            memset(fu, 0, sizeof(fu));    

            random_number = rand() % 9 + 2;    //随机生成2~10个数
            for (i = 0; i < random_number; i++)
            {
                stringstream ss;
                operation_character = rand() % (Max - min + 1) + min;
                Num[i] = operation_character;
                fuhao = rand() % 4 + 1;
                switch (fuhao)
                {
                case 1:sign = "+"; break;
                case 2:sign = "-"; break;
                case 3:sign = "*"; break;
                case 4:sign = "/"; break;
                }
                //若为除法则除数不为零
                while (Num[i] == 0 && i >= 1)
                {
                    if (op_arrays[i - 1] == "/")
                    {
                        operation_character = rand() % (Max - min + 1) + min;
                        Num[i] = operation_character;
                    }
                }
                op_arrays[i] = sign;

                fu[4 * i] = w;
                ss << Num[i];
                ss >> fu[4 * i + 1];
                fu[4 * i + 2] = w;
                if (i != (random_number - 1))   //最后一次不产生符号
                    fu[4 * i + 3] = op_arrays[i];
                else fu[4 * i + 3] = w;
            }
            Jude_has_brackets = rand() % 2 + 1;  //随机确定有无括号
            switch (Jude_has_brackets)
            {
            case 1:
                left = "(";
                right = ")";
                break;
            case 2:
                left = w;
                right = w;
                break;
            }

            for (i = 0; i < random_number; i++)
            {
                for (k = 0; k < (random_number - 1) / 2; k++)
                {
                    fu[4 * k] = left;
                    if (left == "(")
                    {
                        fu[4 * k + 10] = right;
                    }
                }
                if ((fu[4 * i] == left) && (fu[4 * i + 2] == right))
                {
                    fu[4 * i] = w;
                    fu[4 * i + 2] = w;
                }

                All[j] += fu[4 * i] + fu[4 * i + 1] + fu[4 * i + 2] + fu[4 * i + 3];
            }
            cout << j + 1 << "题. " << All[j] << "= " ;
            for (int i = 0; i != All[j].size(); ++i)
            {
                //逐一加入每个字符，这里使用deque因为deque在两端删除添加的速度最快
                coll0.push_back(All[j][i]);      //在尾部加入一个元素
            }

            //将coll0转换为后缀表达式coll1
            for (int i = 0; i != All[j].size(); ++i)
            {
                char k = coll0.front();
                coll0.pop_front();
                if (k != ' ')        //消除空格
                    coll1.push_back(k);
            }
            //从coll中取出元素，分配元素到coll2和coll3中
            allocate(coll1, coll2, coll3);

            //计算后缀表达式
            calculate(coll3, coll4);

            double result = 0;
            cin >> result;
            if (result == coll4.top())
            {
                cout << "正确！" << endl;
                true_num++;
                cout << "计算结果为:" << coll4.top() << endl;
            }
            else
            {
                cout << "错误！" << endl;
                false_num++;
                cout << "计算结果为:" << coll4.top() << endl;
            }
            //将栈清空
            coll4.pop();
        }
        if (true_num >= false_num)
            cout << "恭喜你！您共做对" << true_num << "道题！" << "做错" << false_num << "道题！" << endl;
        else
            cout << "还需加油！您共做对" << true_num << "道题！" << "做错" << false_num << "道题！" << endl;
    }
    else
    {
        random_number = rand() % 9 + 2;    //随机生成2~10个数
        for (j = 0; j < subject_number; j++)    //设置题目数量
        {
            //清除数组元素
            memset(Num, 0, sizeof(Num));
            memset(op_arrays, 0, sizeof(op_arrays));
            memset(fu, 0, sizeof(fu));

            random_number = rand() % 9 + 2;    //随机生成2~10个数
            for (i = 0; i < random_number; i++)
            {
                stringstream ss;
                operation_character = rand() % (Max - min + 1) + min;
                Num[i] = operation_character;
                fuhao = rand() % 2 + 1;
                switch (fuhao)
                {
                case 1:sign = "+"; break;
                case 2:sign = "-"; break;
                }
                op_arrays[i] = sign;

                fu[4 * i] = w;
                ss << Num[i];
                ss >> fu[4 * i + 1];
                fu[4 * i + 2] = w;
                if (i != (random_number - 1))   //最后一次不产生符号
                    fu[4 * i + 3] = op_arrays[i];
                else fu[4 * i + 3] = w;
            }
            Jude_has_brackets = rand() % 2 + 1;  //随机确定有无括号
            switch (Jude_has_brackets)
            {
            case 1:
                left = "(";
                right = ")";
                break;
            case 2:
                left = w;
                right = w;
                break;
            }

            for (i = 0; i < random_number; i++)
            {
                for (k = 0; k < (random_number - 1) / 2; k++)
                {
                    fu[4 * k] = left;
                    if (left == "(")
                    {
                        fu[4 * k + 10] = right;
                    }
                }
                if ((fu[4 * i] == left) && (fu[4 * i + 2] == right))
                {
                    fu[4 * i] = w;
                    fu[4 * i + 2] = w;
                }

                All[j] += fu[4 * i] + fu[4 * i + 1] + fu[4 * i + 2] + fu[4 * i + 3];
            }
            cout << j + 1 << "题. " << All[j] << "= " << endl;
            for (int i = 0; i != All[j].size(); ++i)
            {
                //逐一加入每个字符，这里使用deque因为deque在两端删除添加的速度最快
                coll0.push_back(All[j][i]);      //在尾部加入一个元素
            }

            //将coll0转换为后缀表达式coll1
            for (int i = 0; i != All[j].size(); ++i)
            {
                char k = coll0.front();
                coll0.pop_front();
                if (k != ' ')        //消除空格
                    coll1.push_back(k);
            }
            //从coll中取出元素，分配元素到coll2和coll3中
            allocate(coll1, coll2, coll3);

            //计算后缀表达式
            calculate(coll3, coll4);

            double result = 0;
            cin >> result;
            if (result == coll4.top())
            {
                cout << "正确！" << endl;
                true_num++;
                cout << "计算结果为:" << coll4.top() << endl;
            }
            else
            {
                cout << "错误！" << endl;
                false_num++;
                cout << "计算结果为:" << coll4.top() << endl;
            }
            //将栈清空
            coll4.pop();
        }
        if (true_num >= false_num)
            cout << "恭喜你！您共做对" << true_num << "道题！" << "做错" << false_num << "道题！" << endl;
        else
            cout << "还需加油！您共做对" << true_num << "道题！" << "做错" << false_num << "道题！" << endl;
    }
    return 0;
}


//判断是否为括号
bool isPra(char c)
{
    if (c == '(' || c == ')')
        return true;
    else
        return false;
}

//获得符号的优先性
int getPri(char c)
{
    switch (c)
    {
    case '+':
    case '-':
        return 0;    //如果是加减，返回0
        break;
    case '*':
    case '/':
        return 1;    //如果是乘除，返回1
        break;
    case '(':
    case ')':
        return -1;  //注意，这里将括号设为最低优先级，因此括号不会被弹出，除非遇到右括号
        break;
    }
    return 2;
}

//判断符号的优先性
void check(char c, stack<char>& coll2, deque<char>& coll3)
{
    if (coll2.empty())
    {
        coll2.push(c);
        return;
    }

    if (isPra(c))
    {
        if (c == '(')
            coll2.push(c);
        else
        {
            //弹出所有元素直到遇到左括号
            while (coll2.top() != '(')
            {
                char ch = coll2.top();
                coll3.push_back(ch);
                coll2.pop();
            }

            //当遇到左括号时，弹出但不加入coll3(后缀表达式中）--(“（”“）”都不放入后缀表达式中)
            coll2.pop();  //弹出左括号
        }
    }
    else    //如果不是括号
    {
        //取出栈顶元素，与当前符号进行优先性比较
        char sym = coll2.top();

        //比较两符号的优先性
        if (getPri(c) <= getPri(sym))
        {
            //如果c的优先性比栈顶符号小或等于，弹出栈顶元素
            coll2.pop();
            //并将其压入coll3（后缀表达式）中
            coll3.push_back(sym);
            //递归调用check,比较当前符号c与下一个栈顶符号的优先性
            check(c, coll2, coll3);
        }
        else
        {
            //如果c比栈顶符号优先级大，那将c压入coll2(操作符栈）中
            coll2.push(c);
        }
    }
}

//从coll中取出元素，分配元素到coll2和coll3中
void allocate(deque<char>& coll1, stack<char>& coll2, deque<char>& coll3)
{
    while (!coll1.empty())
    {
        char c = coll1.front();
        coll1.pop_front();

        if (c >= '0'&&c <= '9')
        {
            coll3.push_back(c);
            //判断是否为两位数
            if (!coll1.empty())
            {
                c = coll1.front();
                if (c >= '0'&&c <= '9')
                    coll3.push_back('@');
            }
        }
        else
        {
            //调用check函数，针对不同情况作出不同操作
            check(c, coll2, coll3);
        }

    }

    //如果输入结束，将coll2的元素全部弹出，加入后缀表达式中
    while (!coll2.empty())
    {
        char c = coll2.top();
        coll3.push_back(c);
        coll2.pop();
    }
}


//计算后缀表达式(修改)
void calculate(deque<char>& coll3, stack<double>& coll4)
{
    while (!coll3.empty())
    {
        char c = coll3.front();   //取出第一个元素
        double op = 0;
        coll3.pop_front();   //并弹出此元素
                             //coll3.erase(coll3.begin());
                             //如果是操作数，压入栈中

                             //若是两位数在压入辅助数组后需要进行判断
        if (c >= '0'&&c <= '9')
        {
            op = (c - '0');
            coll4.push(op);
            //cout<<"op="<<op<<endl;
        }
        else if (c == '@')            //如果是两位数则再读一位(若超过两位需要while扩展)
        {
            char d = coll3.front();
            op = coll4.top();
            coll4.pop();
            op = op * 10 + (d - '0');
            coll4.push(op);
            coll3.pop_front();
        }
        else     //如果是操作符，从栈中弹出元素进行计算
        {
            double op1 = coll4.top();
            coll4.pop();
            double op2 = coll4.top();
            coll4.pop();
            switch (c)
            {
            case '+':
                coll4.push(op2 + op1);
                break;
            case '-':
                coll4.push(op2 - op1);
                break;
            case '*':
                coll4.push(op2*op1);
                break;
            case '/':
                coll4.push(op2 / op1);  //注意是op2(op)op1而不是op1(op)op2
                break;
            }
        }
    }
}

结果截图：

工作照：

总结反思：

本次只做了些辅助工作，本来经过上次的实验很有信心想通过完成这次实验来提高自己(确实有所提高，但没有达到预期)，虽然花了足够多的时间，数组转换为字符串、添加真分数这些较为简单的步骤自己都没有完成，效率不高，自己总结下原因有二：1.结对编程对同组大牛有依赖心理 2.没有理清楚思路头绪上来就敲代码（总体表现很慌乱，不知所措），今后一定要先理清思路再动手，有一个明确的方向，要学的很多，努力程度还差很远，加油！