第一周作业——小学四则运算题

作业要求：

　　写一个能自动生成小学四则运算题目的命令行 “软件”， 分别满足下面的各种需求，这些需求都可以用命令行参数的形式来指定：

　　　　a) 支持整数、真分数的四则运算。例如：  1/6 + 1/8 = 7/24

　　　　b) 让程序能接受用户输入答案，并判定对错，最后给出总共 对/错 的数量。

　　　　c) 逐步扩展功能和可以支持的表达式类型，最后希望能支持下面类型的题目（最多 10 个运算符，括号的数量不限制）　　

　　　　　　25 - 3 * 4 - 2 / 2 + 89 = ？
    　　　　 1/2 + 1/3 - 1/4 = ？ 
     　　　　( 5 - 4 ) * ( 3 +28 ) =？

设计思路：

　　定义分数类，重载四则运算符+-*/、赋值符号=、逻辑运算符==和输出输出流。

　　对于整数，看做真分数的一种特例即可。

　　对于算式的生成，先随机生成运算符的数量（题目要求10个，但是针对于小学生而言..十个还是有点多），采用rand() 随机生成分子分母并化简(整数分子为1)，再讲分数转化为字符串，随机生成运算符与随机决定是否括号，再去之前生成的算式拼接。

　　对于算式的结果计算，运用典型的中缀表达式转后缀的算法，定义一个符号栈一个分数栈进行计算。

　　每次生成一个算式并要求使用者给出自己的答案，判断正误，记录结果。

已经实现功能：

1. 随机生成整数或者分数算式，整数算式结果为整数，分数算式结果为真分数
2. 真分数的四则运算，结果为真分数
3. 支持括号
4. 支持判断正误，给出准确率

代码：

　　GitHub: https://github.com/chynphh/Elementary-arithmetic

#include <iostream>
#include <string>
#include <string.h>
#include <math.h>
#include <cstdlib>
#include <cstdio>
#include <ctime>
using namespace std;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAX 1000
#define ADD 100
typedef int Status;


// 整数转字符串
string itoa_i(int x){
    char str[20];
    itoa(x, str, 10);
    return str;

}

//求最大公约数
int gcd(int m,int n){
    if(m%n==0)
        return n;
    else
        return gcd(n,m%n);
}

//分数类
class Fraction{
public:
    Fraction(int x1=0,int z2=1);////构造函数
    void  huajian();//分数化简
    Fraction operator + (Fraction f2);//运算符重载 +
    Fraction operator - (Fraction f2);//运算符重载 -
    Fraction operator * (Fraction f2);//运算符重载 *
    Fraction operator / (Fraction f2);//运算符重载 /
    Fraction& operator= (const Fraction& frac){
           x = frac.x;
        z = frac.z;
        return *this;
    }
    bool operator==(const Fraction &c);

    friend void operator >>(istream& in,Fraction &f);//输入流重载
    friend void operator <<(ostream& out,Fraction &f);//输出流重载


    int x;//分子
    int z;//分母
};

//输出流重载
void operator<<(ostream& out,Fraction &f){
    if(f.x==0) out<<" 0";
    else if(f.z==1) out<<f.x;
    else if(f.z==-1) out<<-1*f.z;
    else{
        if(f.x*f.z>0)
            out<<abs(f.x)<<'/'<<abs(f.z);
        else
             out<<-1*abs(f.x)<<'/'<<abs(f.z);

    }
}

//输入流重载
void operator>>(istream& in,Fraction &f){
    char c;
    in>>f.x;
    in.unsetf(ios::skipws);//
    in>>c;
    in.setf(ios::skipws);//
    if(c != '/'){
        if(c=='
'){
            f.z = 1;
        }
        else{
               in>>f.z;
            throw c;
        }
    }
    else{
        in>>f.z;
        if(f.z == 0)
            throw f.z;
    }
}

//逻辑运算符==重载
bool Fraction::operator==(const Fraction &c){
    if (x == c.x && z == c.z) return true;
    return false;
}

//分数转字符串
string itoa_f(Fraction a){
    string s = "";
    if(a.z == 1) s = s + itoa_i(a.x) + "";
    else s = s + itoa_i(a.x) + "/" + itoa_i(a.z) ;
    return s;
}

//字符串转整数
Fraction atof_f(char* a){
    Fraction f;
    int i = 0, l = 0;
    char* b;
    l = strlen(a);
    while(a[i] != '/' && i < l)i++;
    if(i < l) {
        b = a + i + 1;
        f.z = atoi(b);
    }
    else {
        f.z = 1;
    }

    a[i] = '';
    f.x = atoi(a);

    return f;
}

//构造函数
Fraction::Fraction(int x1,int z2){
    x = x1;
    z = z2;
}

//分数化简
void Fraction::huajian(){
    int gc;
    gc=gcd(abs(x),abs(z));
    x/=gc;
    z/=gc;
}

//运算符重载 +
Fraction Fraction::operator +(Fraction f2){
    int a, b;
    Fraction ff;
    a=x*f2.z+z*f2.x;
    b=z*f2.z;
    ff.x=a;
    ff.z=b;
    ff.huajian();
    return ff;
}

//运算符重载 -
Fraction Fraction::operator -(Fraction f2){
    int a, b;
    Fraction ff;
    a=x*f2.z-z*f2.x;
    b=z*f2.z;
    ff.x=a;
    ff.z=b;
    ff.huajian();
    return ff;
}

//运算符重载 *
Fraction Fraction::operator *(Fraction f2){
    int a, b;
    Fraction ff;
    a=x*f2.x;
    b=z*f2.z;
    ff.x=a;
    ff.z=b;
    ff.huajian();
    return ff;
}

//运算符重载 /
Fraction Fraction::operator /(Fraction f2){
    if(f2.x==0){
        throw f2.x ;
    }
    else{
        int a, b;
        Fraction ff;
        a=x*f2.z;
        b=z*f2.x;
        ff.x=a;
        ff.z=b;
        ff.huajian();
        return ff;
    }
}



//定义字符栈
typedef struct{
        char *top;                  //指向栈顶
        char *base;               //指向栈底(动态分配内存的首地址)
        int     stacksize;          //可用存储空间
}stack_char;

//构造空栈
Status InitStack(stack_char &s){
    s.base=(char *)malloc(MAX * sizeof(char));
    if(!s.base)exit(OVERFLOW);//储存分配失败
    s.top=s.base;
    s.stacksize=MAX;
    return OK;
}

//获取栈顶元素
char GetTop(stack_char s,char &e){
    if (s.top==s.base)return false;
    else
        {
            e = *(s.top-1);
            return OK;
        }
}

//入栈
Status Push(stack_char &s, char e) {
    if(s.top-s.base>=MAX){
        s.base = (char *)realloc(s.base,(s.stacksize + ADD)*sizeof(char));
        if(!s.base)exit(OVERFLOW);
        s.top=s.base+s.stacksize;
        s.stacksize =s.stacksize + ADD;
    }
    *s.top=e;
    s.top++;
    return OK;
}

//出栈
Status Pop(stack_char &s,char &e){
    if(s.top==s.base)return ERROR;
    s.top--;
    e=*s.top;
    return OK;
}


//定义小数栈
typedef struct{
        double *top;      //指向栈顶
        double *base;   //指向栈底(动态分配内存的首地址)
        int     stacksize;  //可用存储空间
}stack_double;

//构造空栈
Status InitStack(stack_double &s){
    s.base=(double *)malloc(MAX * sizeof(double));
    if(!s.base)exit(OVERFLOW);//储存分配失败
    s.top=s.base;
    s.stacksize=MAX;
    return OK;
}

//获取栈顶元素
Status GetTop(stack_double s,double &e){
    if (s.top==s.base)return false;
    else
        {
            e = *(s.top-1);
            return OK;
        }
}

//入栈
Status Push(stack_double &s, double e) {
    if(s.top-s.base>=MAX){
        s.base = (double *)realloc(s.base,(s.stacksize + ADD)*sizeof(double));
        if(!s.base)exit(OVERFLOW);
        s.top=s.base+s.stacksize;
        s.stacksize =s.stacksize + ADD;
    }
    *s.top=e;
    s.top++;
    return OK;
}

//出栈
Status Pop(stack_double &s,double &e){
    if(s.top==s.base)return ERROR;
    s.top--;
    e=*s.top;
    return OK;
}

//定义分数栈
typedef struct{
        Fraction *top;      //指向栈顶
        Fraction *base;   //指向栈底(动态分配内存的首地址)
        int     stacksize;  //可用存储空间
}stack_Fraction;

//构造空栈
Status InitStack(stack_Fraction &s){
    s.base=(Fraction *)malloc(MAX * sizeof(Fraction));
    if(!s.base)exit(OVERFLOW);//储存分配失败
    s.top=s.base;
    s.stacksize=MAX;
    return OK;
}

//获取栈顶元素
Status GetTop(stack_Fraction s,Fraction &e){
    if (s.top==s.base)return false;
    else
        {
            e = *(s.top-1);
            return OK;
        }
}

//入栈
Status Push(stack_Fraction &s, Fraction e) {
    if(s.top-s.base>=MAX){
        s.base = (Fraction *)realloc(s.base,(s.stacksize + ADD)*sizeof(Fraction));
        if(!s.base)exit(OVERFLOW);
        s.top=s.base+s.stacksize;
        s.stacksize =s.stacksize + ADD;
    }
    *s.top = e;
    s.top++;
    return OK;
}

//出栈
Status Pop(stack_Fraction &s,Fraction &e){
    if(s.top==s.base)return ERROR;
    s.top--;
    e = *s.top;
    return OK;
}

char op[7]={ '+','-','*','/','(',')', '#'};
//优先权集合
char priority[7][7]=
{   {'>','>','<','<','<','>','>'},
    {'>','>','<','<','<','>','>'},
    {'>','>','>','>','<','>','>'},
    {'>','>','>','>','<','>','>'},
    {'<','<','<','<','<','=','@'},
    {'>','>','>','>','@','>','>'},
    {'<','<','<','<','<','@','='}   };

char Precede(char a,char b){
    int i,j;
    for(int k=0;k<7;k++){
        if(op[k]==a)i=k;
        if(op[k]==b)j=k;
    }
    return priority[i][j];
}

bool In(char e,char *a){
    int l;
    l=strlen(a);
    bool temp=false;
    for(int i=0;i<l;i++)
    {
        if(a[i]==e)temp=true;
    }
    return temp;
}

template<typename T>
T Operate(T x,char c,T y)
{
    switch(c)
    {
        case'+':return x + y;break;
        case'-':return x - y;break;
        case'*':return x * y;break;
        case'/':return x / y;break;
    }
}

//分数计算
Fraction calculate1(string str){

    stack_char optr;
    stack_Fraction opnd_f;

    InitStack(optr);
    InitStack(opnd_f);

    int l;
    l = str.size();
    str[l] = ' ';
    l++;
    str[l] = '#';
    l++;
    Push(optr,'#');

    int i=0;
    char t;
    GetTop(optr,t);
    while((str[i]!='#'|| t!='#') && i < l){
        if((str[i]=='(' && str[i+1]!='-') || (In(str[i],op)==1 && str[i]!='(')){
            char x,theta;
            Fraction a,b;
            GetTop(optr,t);
            switch(Precede(t,str[i])){
                case '<':
                    Push(optr,str[i]);
                    i++;
                    break;
                case '=':
                    Pop(optr,x);
                    i++;
                    break;
                case '>':
                    Pop(optr,theta);
                    Pop(opnd_f,b);
                    Pop(opnd_f,a);
                    Push(opnd_f,Operate(a,theta,b)) ;
                    break;
            }
        }
        else{
            int k=0;
            char temp[20];
            Fraction x;
            while (str[i+k+1]!=' '){
                k++;
            }
            strncpy(temp,&str[i],k+1);
            temp[k+1]='';
            x = atof_f(temp);
            Push(opnd_f,x);
            i=i+k+1;
        }
        while(str[i]==' ')i++;
        GetTop(optr,t);
    }

    Fraction answer;
    GetTop(opnd_f,answer);
//    cout << answer;
//    cout << endl;
    return answer;
}

//小数计算
double calculate2(string str){

    stack_char optr;
    stack_double opnd_d;
    InitStack(optr);
    InitStack(opnd_d);


    char l;
    l = str.size();
    str[l]='#';
    l++;
    Push(optr,'#');

    int i=0;
    char t;
    GetTop(optr,t);

    while(str[i]!='#'|| t!='#')
    {
        if( In(str[i],op)==1 && str[i]!='(' )
            {
                char x,theta;
                double a,b;
                GetTop(optr,t);
                switch(Precede(t,str[i])){
                    case '<':
                        Push(optr,str[i]);
                        i++;
                        break;
                    case '=':
                        Pop(optr,x);
                        i++;
                        break;
                    case '>':
                        Pop(optr,theta);
                        Pop(opnd_d,b);
                        Pop(opnd_d,a);
                        Push(opnd_d,Operate(a,theta,b)) ;
                        break;
                }
            }
        else{
            int k=0;
            char temp[20];
            double x;
            while((!In(str[i+k+1],op)) || (In(str[i+k+1],op) && str[i+k+2]!=' ')){
                k++;
            }
            strncpy(temp,&str[i],k+1);
            temp[k+1]='';
            x = atof(temp);
            Push(opnd_d,x);
            i=i+k+1;
            while(str[i]==' ')i++;
        }
        GetTop(optr,t);
    }

    double answer;
    GetTop(opnd_d,answer);

    return answer;
}

char opp(int op){
    switch(op){
        case 0: return '+';
        case 1: return '-';
        case 2: return '*';
        case 3: return '/';
    }
}

//随机生成算式
string Create(int type){
    int num_op = 0;
    string exp = "";
    num_op = rand()%10 + 1;//符号个数
    Fraction a;
    int b, c, d;  // b是符号，c是左右部，d是有无括号

    switch(type){
        case 1:
            a.x = rand()%100 + 1;
            a.z = 1;
            a.huajian();
            exp = exp + itoa_f(a);
            while(num_op--){
                b = rand()%4;
                d = rand()%3;
                c = rand()%2;
                if(b == 3) a.x = rand()%5 + 1;  //除法设置除数较小
                else if (b == 2) a.x = rand()%20 +1; // 乘法设置乘数相对较小
                else a.x = rand()%100 +1;
                a.huajian();
                if(c){ //当做左部
                    exp = exp + ' ' + opp(b) + ' ' + itoa_f(a);
                }
                else{ // 当做右部
                    exp = itoa_f(a) + ' ' + opp(b) + ' ' + exp;
                }
                if(b == 0 && num_op > 0){
                    exp = "( " + exp + " )";
                }
            }
            break;
        case 2 :
            break;
        case 3:
            a.x = rand()%30 + 1;
            a.z = rand()%10 + 1;
            a.huajian();
            exp = exp + itoa_f(a);
            while(num_op--){
                b = rand()%4;
                d = rand()%3;
                c = rand()%2;
                if(c){ //当做左部
                    a.x = rand()%30 + 1;
                    a.z = rand()%10 + 1;
                    a.huajian();
                    exp = exp + ' ' + opp(b) + ' ' + itoa_f(a);
                }
                else{ // 当做右部
                    a.x = rand()%30 + 1;
                    a.z = rand()%10 + 1;
                    exp = itoa_f(a) + ' ' + opp(b) + ' ' + exp;
                }
                if(b == 0 && num_op > 0){
                    exp = "( " + exp + " )";
                }
            }
            break;
    }
    return exp;
}

int start(int num, int type){
    int num_right = 0;
    string exp;
    Fraction std_ans_f, ans_f;
    double std_ans_d = 0.0, ans_d = 0.0;

    while(num--){
        exp = Create(type);
        if(type != 2){//整数 或者 真分数运算
            std_ans_f = calculate1(exp);
            if(type == 1)//整数运算保证结果为整数
                while(std_ans_f.z != 1){
                    exp = Create(type);
                    std_ans_f = calculate1(exp);
                }
            cout << "Q:"<<  exp << " " << endl;
            cout << "your ans:" ;
            cin >> ans_f;
            cout << "the right ans:";
            cout << std_ans_f ;
            cout << endl << endl;

            if(std_ans_f == ans_f)num_right++;
        }
        else{//小数部分 未完善

        }
        exp="";
    }
    return num_right;
}


int main ()
{
    srand(time(0));        //初始化随机数发生器

    int type = -1, num = 0, num_right = 0;
    double acc = 0.0;
    cout << "Please select the type of problem: 
1.integer
2.decimals
3.fraction
";
    cin >> type;
    while(type < 1 || type > 3){
        cout << "Please select the correct type of problem" << endl;
        cin >> type;
    }
    cout << "please input the number of problems " << endl;
    cin >> num;
    num_right = start(num, type);
    acc = num_right * 1.0 / num;
    cout << "The number of question : " << num << endl;
    cout << "The number of correct answer : "<< num_right << endl;
    cout << "your accuracy is " << acc <<endl;
    return 0;
}

使用说明：

　　每次选择算式类型：1.整数 2.小数（还未实现完整）3.分数。再输入题目数量。

　　运算数与运算符之间用空格隔开，如：“1/2 / 2“”表示分数1/2除以2，而“1 / 2 / 2”表示1除以2再除以2）

运行截图：

　　

　　

后期优化计划：

1. 已经完成小数的栈与表达式的计算部分的代码，后续抽空完成表达式生成的部分。（不过小学生还不会小数吧…）
2. 运用模板来简化代码（三个栈，两个计算），减少代码量
3. 支持混合运算。
4. 支持用户输入运算的范围与算符数量。

暂时无法解决的问题（博主实在弱鸡...请求助教帮助..）：

1. 程序大多时候能正常运行，但是有时候会出错（针对于同样的输入信息有时候会出粗有时候不会，如下面选择整数，产生2道题目）。产生的题目数不够但自动结束，且没有报错信息。。

　　　

　　　　（错误的）

　　　

　　　　（正确的）

　　2.单步调试的时候，每次在计算函数calculate1()，最后return时，会报下面错误：