软工第二次作业

GIT地址	https://github.com/Cpu8285
GIT名称	Cpu8285
学号后五位	64222
博客地址	https://www.cnblogs.com/565118008a/
作业地址	https://www.cnblogs.com/ChildishChange/p/10398212.htm

 

 

 

 

 

1.配置环境

试了很多钟方法，VS2017无法安装，可能我的电脑不适配，然后改下VS2015,居然这么久，惊了。。。

 

 2.代码

 

 

 

#include <bits/stdc++.h>

using namespace std;

mt19937 mt(time(0)); // 随机数生成器

map<int, char> op; // 运算符id及其符号映射
map<int, int> pri; // 运算符id及其优先级映射
// 10表示加号   运算优先级为 0
// 11表示减号   运算优先级为 0
// 12表示乘号   运算优先级为 1
// 13表示除号   运算优先级为 1
// 14表示左括号 运算优先级为 2
// 15表示右括号 运算优先级为 2

// 运算数结构体，id为运算数的位置，val为运算数的值
struct node{
    int id, val;
    node(int id = -1, int val = -1):id(id), val(val){}
};

// tot：逆波兰表达式的长度，operatorNum：运算符个数
// operandNum：运算数的个数，bracketNum：括号对数，ans：运算式最终答案
// hasBracket：某个数字处是否有括号，-1表示无括号，14表示左括号，15表示右括号
// operators：对应位置的运算符种类 operands：表示对应位置运算数的值
// RPN：存储逆波兰表达式 fac：存储某个数的约数
// opr：中缀表达式转后缀表达式时的运算符栈
// opd：中缀表达式转后缀表达式时的运算数栈

int tot, operatorNum, operandNum, bracketNum, ans;
int hasBracket[15], operators[15], operands[15];
int RPN[55], fac[105];
stack<int> opr;
stack<node> opd;

// 初始化函数零：初始化运算符 id 符号 以及运算优先级，并且重定向输出
void init0(){
    op[10] = '+', op[11] = '-';
    op[12] = '*';
    op[14] = '(', op[15] = ')';
    pri[10] = 0, pri[11] = 0;
    pri[12] = 1, pri[13] = 1;
    pri[14] = 2, pri[15] = 2;
    freopen("../result.txt", "w", stdout);
}

// 初始化函数一：在每次调用solve()时进行初始化
void init1(){
    tot = 0;
    for(int i = 0; i < 15; ++i){
        operators[i] = -1;
        operands[i] = -1;
        hasBracket[i] = -1;
    }
    while(!opr.empty()) opr.pop();
    while(!opd.empty()) opd.pop();
}

// 初始化函数二：在每次调用getOperands()时进行初始化
void init2(){
    tot = 0;
    while(!opr.empty()) opr.pop();
    while(!opd.empty()) opd.pop();
}

// 获取运算数的值的函数，如果返回 true 则表示获取成功，否则表示获取失败
bool getOperands(){
    init2();
    // 将中缀表达式转换成后缀表达式（也就是逆波兰表达式）
    if(hasBracket[0] != -1) opr.push(hasBracket[0]);
    RPN[tot++] = 0;
    for(int i = 1; i < operandNum; ++i){
        while(true){
            if(opr.empty() || opr.top() == 14 || pri[operators[i - 1]] > pri[opr.top()]){
                opr.push(operators[i - 1]);
                break;
            }
            RPN[tot++] = opr.top();
            opr.pop();
        }
        if(hasBracket[i] == 14){
            opr.push(hasBracket[i]);
        }
        RPN[tot++] = i;
        if(hasBracket[i] == 15){
            while(opr.top() != 14){
                RPN[tot++] = opr.top();
                opr.pop();
            }
            opr.pop();
        }
    }
    while(!opr.empty()){
        RPN[tot++] = opr.top();
        opr.pop();
    }
    // 转换成逆波兰表达式后便可以进行尝试填数
    for(int i = 0; i < tot; ++i){
        // 如果为运算数则随机为其赋值
        if(RPN[i] < 10){
            int x = mt()%66 + 1;
            operands[RPN[i]] = x;
            opd.push(node(RPN[i], x));
            continue;
        }
        //如果为除法，要将除数随机分配为被除数的一个因子
        //如果为减法，要注意减数不能大于被减数

        if(RPN[i] == 13){
            node b = opd.top(); opd.pop();
            node a = opd.top(); opd.pop();
            if(a.val%b.val == 0){
                opd.push(node(-1, a.val/b.val));
                continue;
            }
            if(b.id == -1) return false;
            int cnt = 0;
            for(int j = 1; j <= a.val; ++j){
                if(j >= 100) break;
                if(a.val%j) continue;
                fac[cnt++] = j;
            }
            int x = mt()%cnt;
            operands[b.id] = fac[x];
            opd.push(node(-1, a.val/fac[x]));
        }else if(RPN[i] == 11){
            node b = opd.top(); opd.pop();
            node a = opd.top(); opd.pop();
            int dt = a.val - b.val;
            if(dt <= 0) return false;
            opd.push(node(-1, dt));
        }else{
            node b = opd.top(); opd.pop();
            node a = opd.top(); opd.pop();
            if(RPN[i] == 10) opd.push(node(-1, a.val + b.val));
            if(RPN[i] == 12) opd.push(node(-1, a.val*b.val));
        }
    }
    ans = opd.top().val; opd.pop();
    //控制最终运算结果的范围，可根据需要进行调节
    if(ans < 0 || ans > 1000) return false;
    return true;
}

bool solve(){
    init1();
    // 随机生成运算符的个数 3~5 ，及运算数个数 4~6
    operatorNum = mt()%3 + 3;
    operandNum = operatorNum + 1;
    // 随机生成括号个数
    bracketNum = min((int)(operandNum/2), (int)(mt()%3 + 2));
    // 随机生成运算符的种类
    for(int i = 0; i < operatorNum; ++i) operators[i] = mt()%4 + 10;
    // 随机生成括号位置
    for(int i = 0; i < bracketNum*2; ++i){
        int x = mt()%operandNum;
        while(hasBracket[x] != -1) x = mt()%operandNum;
        hasBracket[x] = 0;
    }

    // 根据相对位置确定括号为左括号还是右括号
    bool lf = true;
    for(int i = 0; i < operandNum; ++i){
        if(hasBracket[i] == -1) continue;
        if(lf) hasBracket[i] = 14;
        else hasBracket[i] = 15;
        lf = (!lf);
    }

    // 到这里已经将等式预处理成了(a+b)/c*(d-e)的类似形式
    // 预处理结束之后，我们就要尝试将 a b c d e 确定为具体的数
    if(!getOperands()) return false;

    // 在获取完运算数之后，便可以输出我们得到的等式了
    if(hasBracket[0] != -1) printf("(");
    printf("%d", operands[0]);
    for(int i = 1; i < operandNum; ++i){
        if(operators[i - 1] == 13) printf("÷");
        else printf("%c", op[operators[i - 1]]);
        if(hasBracket[i] == 14) printf("(");
        printf("%d", operands[i]);
        if(hasBracket[i] == 15) printf(")");
    }
    printf("=%d\n", ans);
    return true;
}


int main(){
    // 初始化函数零：初始化运算符 id 符号 以及运算优先级，并且重定向输出
    init0();
    //读入需要生成的运算式数量
    int n;
    while(n--) while(!solve()) ;

    return 0;
}

3.GIT软件上传GITHUB，VS2017无法下载，所以暂时无从下手。

4·感想

完成质量有点差，早上八点到晚上九点一直再赶，到后面只是把代码研究了出来，其他根本无从下手，

融入新事物的能力差，已经养成依赖老师讲解的思维，到自己做的时候就无所适从，这是我的一个很大

问题。