四则运算第一次晋级

核心思想:使用运算类，一个条件一个成员函数，从主函数中输入判断是否满足条件

对于其他条件星期三下午完成

难点:括号的填充，用了星期六一天时间，直到星期六下午才完成，没有使用数据结构。

生成括号思想:

　　1.产生多项式个数，以及每个多项式的数字个数，随机产生，使用二维数组储存，一维代表多项式个数，二维代表每个多项式的数字个数。

　　2.根据每个多项式产生的数字个数，产生四则运算符号的个数使用二维数组储存，一维代表多项式个数，二维代表每个多项式的四则运算个数。

　　3.利用二维数组储存括号产生的位置，将括号根据位置插入进去。

生成括号遇到的问题:

　　1.左右括号的位置产生的条件不好限制。

　　2.而且括号的数量我用了人为控制为两个。

　　3.号位置的产生还可能重复，导致只有左括号或者只有右括号

虽然经过一番辛苦捉摸做完了，但是绕了很大的圈子，原因:

　　1.开始做之前没有经过自己的详细思考，只是大致有了自己的思路就开始做，没有考虑细节。

　　2.写程序不能一气呵成，导致在写的过程中不能很好的前后联系起来，效率降低了许多。

　　3.遇到困难心浮气躁，不能冷静下来思考，浪费了好多时间。

结果截图：

代码：

#pragma once
#include <iostream>
#include <string>
using namespace std;
#include <cmath>
#include <ctime>
#include <iomanip>

class operation
{
private:
        int Fnum[100];
        int    Snum[100];
        string mark[100];
        int    manynum[10][10];
        int    count;
        string savemark[10][10];
        int number;            //多项式的个数
        int savenumbers[10];        //每一个多项式含有几个数
        string position[10][10];

public:
    operation();
    void Input(int c);
    /*int Range(int r1,int r2);        //随机产生的数或符号可以在主函数中控制
    int MandD(judge md);*/
    int Remainder(int num1,int num2);
    int Negative(int num1,int num2);
    int Bractets(int judgebra);
    void Save(int num1,int num2,string str,int num);
    int Repat(int num1,int num2,string str);
    int Manynum(int min,int max,int judge,int i);
    void Output(int judge,int num);
    ~operation(void);
};

#include "operation.h"

operation::operation()
{
    for(int i=0;i<100;i++)
    {
        Fnum[i]=0;
        Snum[i]=0;
        mark[i]='0';
    }
    count=0;
    for(int m=0;m<10;m++)
        for(int n=0;n<10;n++)
        {
            savemark[m][n]=" ";
            manynum[m][n]=0;
            position[m][n]=" ";
        }
}

void operation::Input(int c)
{
    count=c;
}
/*int operation::Range(int r1,int r2)
{
    int s=10
    return s;
}*/
int operation::Remainder(int num1,int num2)
{
    if(num1%num2==0)                    //没有余数
        return true;
    else
        return false;
}

int operation::Negative(int num1,int num2)
{
    if(num1>num2)
        return true;
    else
        return false;
}
void operation::Save(int num1,int num2,string str,int num)
{
    Fnum[num]=num1;
    Snum[num]=num2;
    mark[num]=str;
}
int operation::Repat(int num1,int num2,string str)
{
    int flag=1;
    for(int i=0;i<count;i++)
    {
        if(Fnum[i]==num1&&Snum[i]==num2&&mark[i]==str)
            flag=0;
    }

    return flag;
}

int operation::Manynum(int min,int max,int judge,int i)
{
    string sympol[4]={"+","-","*","÷"};
    srand((unsigned)time(0));
    number = 1+rand()%8;
    while(number>count)
    {
        number=rand()%8;
    }

    int numbers;
    for(int m=0;m<number;m++)            //产生多项式
    {
        numbers=3+rand()%8;
        savenumbers[m]=numbers;
        for(int n=0;n<numbers;n++)
        {
            manynum[m][n]=min+rand()%(max-min);    
        }
        if(judge)                            //产生符号
        {
            for(int n=0;n<numbers-1;n++)
            {
                savemark[m][n]=sympol[rand()%4];
            }
        }
        else
        {
            for(int n=0;n<numbers-1;n++)
            {
                savemark[m][n]=sympol[rand()%2];
            }
        }
    }

    int pos[3];
    for(int m=0;m<3;m++)
        pos[m]=0;
    for(int m=0;m<number;m++)
    {
        for(int t=0;t<savenumbers[m];t++)                //没有设置内层循环跳出条件
        {
            if(savenumbers[m]>3&&savenumbers[m]<=10)
            {
                for(int s=0;s<2;s++)
                {
                    pos[s]=rand()%(savenumbers[m]/2);//可能随机产生相同的位置抵消了
                    
                    while(position[m][pos[s]]!=" ")
                    {
                        pos[s]=rand()%(savenumbers[m]/2);
                    }
                    position[m][pos[s]]="(";
                }
                
                for(int s=0;s<2;s++)
                {
                    pos[s]=savenumbers[m]/2+rand()%(savenumbers[m]/2);
                    while(position[m][pos[s]]!=" ")
                    {
                        pos[s]=savenumbers[m]/2+rand()%(savenumbers[m]/2);
                    }
                    position[m][pos[s]]=")";
                }
                t=savenumbers[m];
            }
        }
    }

    return i+number;
}

void operation::Output(int judge,int num)
{
    for(int i=num;i<count;i++)
    {
        cout<<setw(2)<<left<<Fnum[i]<<"  "<<setw(2)<<left<<mark[i]<<"  "<<setw(2)<<left<<Snum[i]<<endl;
    }

    if(judge)
    {
        for(int m=0;m<number;m++)
        {
            for(int n=0;n<savenumbers[m];n++)
            {
                if(position[m][n]=="(")
                    cout<<position[m][n]<<manynum[m][n]<<savemark[m][n];
                else
                    cout<<manynum[m][n]<<position[m][n]<<savemark[m][n];
            }
            cout <<endl;
        }
    }
}
operation::~operation(void)
{
}

#include<iostream>
#include "operation.h"
using namespace std;

int main()
{
    int count,
        judgeDiv,
        judgeRem,
        judgeNev,
        judgeBra,
        judgeRan;
    string mark[4]={"+","-","*","÷"};
    operation operate;
    srand((unsigned)time(0));
    
    cout <<"请输入要产生的计算题数量(0-88):";
    cin>>count;
    if(count>88||count<0)
    {
        cout<<"你输入的数值不满足要求，将将产生88个题目"<<endl;
        count=88;
    }
    operate.Input(count);
    
    cout <<"产生的数是否有范围限制(1是或0否):";
    cin>>judgeRan;

    int min=0,max=100;
    if(judgeRan)
    {
        cout <<"请输入最小值(默认最小值为0):";
        cin>> min;
        if(min<0)
            min=0;

        cout <<"请输入最大值(默认最大值为100):";
        cin>>max;
        if(max>100)
            max=100;
    }

    cout <<"产生的题目是否有乘除法(1是或0否):";
    cin>>judgeDiv;

    cout <<"产生的题目结果是否有余数(1是或0否):"; //有问题,已经解决
    cin>>judgeRem;

    cout <<"题目结果是否有负数(1是或0否):";
    cin>>judgeNev;

    cout <<"产生的题目是否有括号(1是或0否):";
    cin>>judgeBra;

    int i=0;
    int m;
    if(judgeBra)
        m=operate.Manynum(min,max,judgeDiv,i);
    for(i=m;i<count;i++)
    {
        int num1,num2;
        string sympol;
        num1=min+rand()%(max-min);
        num2=min+rand()%(max-min);

        
        if(judgeDiv)
        {
            sympol=mark[rand()%4];
        }
        else
        {
            sympol=mark[rand()%2];
        }

        if(!judgeRem&&sympol=="÷")        //除法有问题,2016/3/17/17:05解决
        {
            while(num1%num2!=0)
            {
                num1=min+rand()%(max-min);
                num2=min+rand()%(max-min);
            }
        }
        if(!judgeNev&&sympol=="-")
        {
            int mid;
            if(num1<num2)
            {
                mid=num1;
                num1=num2;
                num2=mid;
            }
        }
        if(operate.Repat(num1,num2,sympol))
        {
            operate.Save(num1,num2,sympol,i);
        }
        else
            continue;

    }
    operate.Output(judgeBra,m);
    return 0;
}