四则运算2及PSP0设计项目计划

时间比较紧，我简单写写我的设计思路：

题目在四则运算1的基础上控制产生题目的数量，这个可以用变量控制；打印方式也可选用变量控制，程序的关键是括号的生成。我们可以将整个四则运算式看成()+()的模型，然后再利用递归函数对这个模型进行分解（这个函数我一直在调试但感觉还没有完善，时间比较紧，到后面我会补上）。

关于括号生成目前是有问题的，目前发现使用了string[][]这样会导致为三维数组存在很大问题，所以请参考者注意一下。

下面是我的源程序代码：

 //author:ly 2016.3.12
 /*function:arithmetic operation that avoid duplication
  can order question number
  can select division and multiplication
  can choose brackets
  Specified range of operation
 */
 #include<iostream>
 #include<time.h>
 #include<sstream>
 #include<string>
 #include<fstream>
 using namespace std;

 string Judge[][];   //判断是否重复的数组
 string para[];       //备用数组
 char op_arrays[]={'+','-','*','/'};   //运算符数组
 int row=;   //定义行
 int ran=;   //定义列
 int k=;
 int parameters[];           //定义参数数组
 void Random_build1(int,int,int);    //产生算术式的函数
 void Random_build2(int,int,int);
 void Random_build3(int,int,int);
 void Random_build4(int,int,int);
 void Decu(int,int,int);      //递归函数

 int main()
 {
     //对于产生括号的运算生成还有问题 希望老师看了能给我在博客中指点一下问题所在

     int count_t=;     //产生题目数量
     char print_way;    //判断打印方式
     char Jude_has_mul_dev;    //判断是否有乘除法
     char  Jude_has_brackets;   //判断是否有括号

     int parameters_num=;     //参数个数
     int rangeof_count=;    //指定计数的范围
     int brackets_l=;     //判断左括号的序数
     int brackets_r=;     //判断右括号的序数

     cout<<"请输入需要产生四则元算的题数："<<endl;
     cin>>count_t;

     while()
     {
     //判断有无乘除法
     cout<<"是否需要做乘除  是（输入y） 否（输入n）"<<endl;
     cin>>Jude_has_mul_dev;
     cout<<"判断是否需要括号 是（输入y） 否（输入n）"<<endl;
     cin>> Jude_has_brackets;
     cout<<"判断你需要做的计算的范围(小于1000)："<<endl;
     cin>>rangeof_count;

      srand(time(NULL));//用系统当前时间设置rand()随机序列种子，保证每次运行随机序列不一样
      memset(Judge,,sizeof(Judge));
      memset(parameters,,sizeof(parameters));
     while(row<count_t)
     {
        parameters_num=+rand()%;   //产生2-10个随机数
        ran=;
           k=0;
        memset(para,,sizeof(para));

     if(Jude_has_mul_dev=='n')
     {
         //不含乘除法
         if(Jude_has_brackets=='n')
         {
             //不含括号
             //调用产生算术式的函数
             int i=;

             while(i<=parameters_num)
             {
                 Random_build2(parameters_num, rangeof_count, i);
                 i++;
             }
             parameters[row]=ran;    //记录每次产生参数的个数

        }
         else
         {
             //产生括号(采用递归方式产生括号)
             //先产生算术式 并用数组记录
             int i=,s,l;
             int flag=; //判断递归函数中是否生成括号
             while(i<=parameters_num)
             {
                 Random_build3(parameters_num, rangeof_count, i);
                 i++;
             }

             s=k,l=;

             Decu(l,k,flag);

             parameters[row]=ran;    //记录每次产生参数的个数

       }
     }
     else
     {
         //含乘除法
         if(Jude_has_brackets=='n')
         {
             //不含括号
             int i=;
             while(i<=parameters_num)
             {
                 Random_build1(parameters_num, rangeof_count, i);
                 i++;
             }
                 parameters[row]=ran;    //记录每次产生参数的个数
         }
         else
         {
             //含括号
             //产生括号(采用递归方式产生括号)
             //先产生算术式 并用数组记录
             int i=,s,l;
             int flag=; //判断递归函数中是否生成括号
             while(i<=parameters_num)
             {
                 Random_build4(parameters_num, rangeof_count, i);
                 i++;
             }
             s=k,l=;

             Decu(l,k,flag);
             parameters[row]=ran;    //记录每次产生参数的个数
         }
     }
           row++;    //运算式的行数
     }

     cout<<"请输入你需要的打印方式：(输入a 在控制台打印输出 输入b 在文件中输出)"<<endl;
     cin>>print_way;

     if(print_way=='a')
     {
     //打印产生的运算表达式
     cout<<"产生的运算表达式为："<<endl;
     for(int i=;i<count_t;i++)
     {
         cout<<i+<<". ";
         for(int j=;j<=parameters[i];j++)
             cout<<Judge[i][j];
         cout<<endl;
     }
     }
     else
     {
         //将产生的四则运算表达式输出到D:\1.txt中
         ofstream out("D:\1.txt");
         for(int i=;i<count_t;i++)
     {
         out<<i+<<". ";
         for(int j=;j<=parameters[i];j++)
             out<<Judge[i][j];
         out<<endl;
     }
     }
  }
     return ;
 }

 void Random_build1(int parameters_num,int rangeof_count,int i)
 {
     int parameters;
     int fuhao=;
     stringstream ss;
     //随机产生 运算表达数
     parameters=+rand()%rangeof_count;
     //判断上一次产生的是否除法
     if(fuhao==)
     {
        while(parameters==)     //除数为0就重新生成
         {
             parameters=+rand()%rangeof_count;
         }
     }
     //随机产生 运算符(最后一次不产生运算符)
     if(i<parameters_num)
     {
         fuhao=((+rand()%)+)%;
     }
     if(i<parameters_num)
     {
         //将产生的数放入判断重复的数组中
         ss<<parameters;
         ss>>Judge[row][ran];
         ran++;    //列增加
         Judge[row][ran]=op_arrays[fuhao];
         ran++;    //列增加
     }
     else
     {
         ss<<parameters;
         ss>>Judge[row][ran];
     }
 }

 void Random_build2(int parameters_num,int rangeof_count,int i)
 {
     int parameters;
     int fuhao;
     stringstream ss;
     //随机产生 运算表达数
     parameters=+rand()%rangeof_count;

     //随机产生 运算符(最后一次不产生运算符)
     if(i<parameters_num)
     {
          fuhao=((+rand()%)+)%;
     }
     if(i<parameters_num)
     {
         //将产生的数放入判断重复的数组中
         ss<<parameters;
         ss>>Judge[row][ran];
         ran++;    //列增加
         Judge[row][ran]=op_arrays[fuhao];
         ran++;    //列增加
     }
     else
     {
         ss<<parameters;
         ss>>Judge[row][ran];
     }
 }

 void Random_build3(int parameters_num,int rangeof_count,int i)
 {
     int parameters;
     int fuhao;
     stringstream ss;
     //随机产生 运算表达数
     parameters=+rand()%rangeof_count;

     //随机产生 运算符(最后一次不产生运算符)
     if(i<parameters_num)
     {
          fuhao=((+rand()%)+)%;
     }
     if(i<parameters_num)
     {
         //将产生的数以字符放入判断重复的数组中
         ss<<parameters;
         ss>>para[k];
         k++;    //列增加

         para[k]=op_arrays[fuhao];
         k++;    //列增加
     }
     else
     {
         ss<<parameters;
         ss>>para[k];
     }
 }

 void Random_build4(int parameters_num,int rangeof_count,int i)
 {
     int parameters;
     int fuhao=;
     stringstream ss;
     //随机产生 运算表达数
     parameters=+rand()%rangeof_count;
     if(fuhao==)
     {
        while(parameters==)     //除数为0就重新生成
         {
             parameters=+rand()%rangeof_count;
         }
     }
     //随机产生 运算符(最后一次不产生运算符)
     if(i<parameters_num)
     {
          fuhao=((+rand()%)+)%;
     }
     if(i<parameters_num)
     {
         //将产生的数以字符放入判断重复的数组中
         ss<<parameters;
         ss>>para[k];
         k++;    //列增加

         para[k]=op_arrays[fuhao];
         k++;    //列增加
     }
     else
     {
         ss<<parameters;
         ss>>para[k];
     }
 }

 void Decu(int l,int s,int flag)
 {
     //srand(time(NULL));//用系统当前时间设置rand()随机序列种子，保证每次运行随机序列不一样

     if((s-l)<) return ;

     if((s-l)==)
     {
         if(flag==)
         {
             //产生括号
           Judge[row][ran]="(";
           ran++;
           Judge[row][ran]=para[l];
           ran++;
           Judge[row][ran]=para[l+];
           ran++;
           Judge[row][ran]=para[s];
           ran++;
           Judge[row][ran]=")";
           ran++;
         }
         if(flag==)
         {
           Judge[row][ran]=para[l];
           ran++;
           Judge[row][ran]=para[l+];
           ran++;
           Judge[row][ran]=para[s];
           ran++;
         }
         return ;
     }
     if((s-l)==)
     {
         //存在随机数个数为奇数的情况
         flag=+rand()%;
         if(flag==)
         {
          Judge[row][ran]="(";
          ran++;
          Judge[row][ran]=para[l];
          ran++;
          Judge[row][ran]=para[l+];
          ran++;
          flag=+rand()%;
          Decu(l+,s,flag);
          Judge[row][ran]=")";
           ran++;
         }
         if(flag==)
         {
              Judge[row][ran]=para[l];
          ran++;
          Judge[row][ran]=para[l+];
          ran++;
          flag=+rand()%;
          Decu(l+,s,flag);
         }
           return ;
     }

     if((s-l)>)
     {
             flag=+rand()%;
         if(flag==)
         {
          Judge[row][ran]="(";
          ran++;
              flag=+rand()%;
          Decu(l,s-,flag);
          Judge[row][ran]=para[s-];
          ran++;
          l=s-;
          flag=+rand()%;
          Decu(l,s,flag);
          Judge[row][ran]=")";
           ran++;
         }
         if(flag==)
         {
             flag=+rand()%;
          Decu(l,s-,flag);
          Judge[row][ran]=para[s-];
          ran++;
          l=s-;
          flag=+rand()%;
          Decu(l,s,flag);
         }
           return ;
     }
 }

运行截图：

PSP0设计：

周活动日志：

	听课	编写程序	阅读课本	日总计
周一	100	180	0	280
周二	0	200	0	200
周三	0	180	0	180
周四	100	200	80	380
周五	0	200	60	260
周六	0	300	60	360
周日
周总计	200	1260	200	1660

时间记录日志：

日期	开始时间	结束时间	中断时间	净时间	活动	备注
7/3	14:00	15:50	10	100	上课	讲座
	16:00	18:00	0	120	编程序	作业2
8/3	8:00	12:00	20	220	上课	讲座
	14:00	15:40	0	100	编程序	作业2（递归函数）
9/3	8:00	12:00	20	220	上课	讲座
	19:00	23:00	20	220	看书、编程	听歌休息
10/3	14:00	18:00	20	220	上课	讲座（javaEE）
	19:00	21:00	0	120	java学习	servlet编写
11/3	8:00	9:40	0	100	编写程序	作业2 （递归函数+排bug）
	16:00	18:00	0	120	编写程序	边界条件测试
12/3	8:00	12:00	60	180	编写程序+背英语	作文加深+测试程序

缺陷记录日志：

日期	编号	类型	引入阶段	排除阶段	修复时间	修复缺陷
9/3	1		编写代码	debug	300+
	产生括号的情况太单一，在此基础上重写括号生成代码
11/3	2		编写代码	询问	120	int 和Sting 转换
	意识到自以为的C++好多知识根本不知道
12/3	3		编写	调试（多组数据）	&	代码存在的bug
	在括号数量多以后数组存放有问题，目前还未解决