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

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

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

下面是我的源程序代码：关于括号生成目前是有问题的，请大家看后可以帮我指一下问题。

  1 //author:ly 2016.3.12
  2 /*function:arithmetic operation that avoid duplication
  3  can order question number
  4  can select division and multiplication
  5  can choose brackets
  6  Specified range of operation
  7 */
  8 #include<iostream>
  9 #include<time.h>
 10 #include<sstream>
 11 #include<string>
 12 #include<fstream>
 13 using namespace std;
 14 
 15 string Judge[30][30];   //判断是否重复的数组
 16 string para[30];       //备用数组
 17 char op_arrays[4]={'+','-','*','/'};   //运算符数组
 18 int row=0;   //定义行
 19 int ran=0;   //定义列
 20 int k=0;
 21 int parameters[30];           //定义参数数组
 22 void Random_build1(int,int,int);    //产生算术式的函数
 23 void Random_build2(int,int,int);    
 24 void Random_build3(int,int,int);  
 25 void Random_build4(int,int,int);  
 26 void Decu(int,int,int);      //递归函数
 27 
 28 int main()
 29 {
 30     //对于产生括号的运算生成还有问题 希望老师看了能给我在博客中指点一下问题所在
 31 
 32     int count_t=0;     //产生题目数量
 33     char print_way;    //判断打印方式
 34     char Jude_has_mul_dev;    //判断是否有乘除法
 35     char  Jude_has_brackets;   //判断是否有括号
 36 
 37     int parameters_num=0;     //参数个数
 38     int rangeof_count=0;    //指定计数的范围
 39     int brackets_l=0;     //判断左括号的序数
 40     int brackets_r=0;     //判断右括号的序数
 41 
 42     cout<<"请输入需要产生四则元算的题数："<<endl;
 43     cin>>count_t;
 44 
 45     while(1)
 46     {
 47     //判断有无乘除法 
 48     cout<<"是否需要做乘除  是（输入y） 否（输入n）"<<endl;
 49     cin>>Jude_has_mul_dev;
 50     cout<<"判断是否需要括号 是（输入y） 否（输入n）"<<endl;
 51     cin>> Jude_has_brackets;
 52     cout<<"判断你需要做的计算的范围(小于1000)："<<endl;
 53     cin>>rangeof_count;
 54 
 55      srand(time(NULL));//用系统当前时间设置rand()随机序列种子，保证每次运行随机序列不一样 
 56      memset(Judge,0,sizeof(Judge));
 57      memset(parameters,0,sizeof(parameters));
 58     while(row<count_t)
 59     {
 60        parameters_num=2+rand()%9;   //产生2-10个随机数
 61        ran=0;
           k=0;
 62        memset(para,0,sizeof(para));
 63 
 64     if(Jude_has_mul_dev=='n')
 65     {
 66         //不含乘除法
 67         if(Jude_has_brackets=='n')
 68         {
 69             //不含括号
 70             //调用产生算术式的函数
 71             int i=1;
 72 
 73             while(i<=parameters_num)
 74             {
 75                 Random_build2(parameters_num, rangeof_count, i);
 76                 i++;
 77             }
 78             parameters[row]=ran;    //记录每次产生参数的个数
 79 
 80        }
 81         else
 82         {
 83             //产生括号(采用递归方式产生括号)
 84             //先产生算术式 并用数组记录
 85             int i=1,s,l;
 86             int flag=1; //判断递归函数中是否生成括号
 87             while(i<=parameters_num)
 88             {
 89                 Random_build3(parameters_num, rangeof_count, i);
 90                 i++;
 91             }
 92 
 93             s=k,l=0;
 94 
 95             Decu(l,k,flag);
 96 
 97             parameters[row]=ran;    //记录每次产生参数的个数
 98 
 99       }
100     }
101     else
102     {
103         //含乘除法
104         if(Jude_has_brackets=='n')
105         {
106             //不含括号
107             int i=1;
108             while(i<=parameters_num)
109             {
110                 Random_build1(parameters_num, rangeof_count, i);
111                 i++;
112             }
113                 parameters[row]=ran;    //记录每次产生参数的个数
114         }
115         else
116         {
117             //含括号
118             //产生括号(采用递归方式产生括号)
119             //先产生算术式 并用数组记录
120             int i=1,s,l;
121             int flag=1; //判断递归函数中是否生成括号
122             while(i<=parameters_num)
123             {
124                 Random_build4(parameters_num, rangeof_count, i);
125                 i++;
126             }
127             s=k,l=0;
128             
129             Decu(l,k,flag);
130             parameters[row]=ran;    //记录每次产生参数的个数
131         }
132     }
133           row++;    //运算式的行数
134     }
135 
136     cout<<"请输入你需要的打印方式：(输入a 在控制台打印输出 输入b 在文件中输出)"<<endl;
137     cin>>print_way;
138 
139     if(print_way=='a')
140     {
141     //打印产生的运算表达式
142     cout<<"产生的运算表达式为："<<endl;
143     for(int i=0;i<count_t;i++)
144     {
145         cout<<i+1<<". ";
146         for(int j=0;j<=parameters[i];j++)
147             cout<<Judge[i][j];
148         cout<<endl;
149     }
150     }
151     else
152     {
153         //将产生的四则运算表达式输出到D:\1.txt中
154         ofstream out("D:\1.txt");
155         for(int i=0;i<count_t;i++)
156     {
157         out<<i+1<<". ";
158         for(int j=0;j<=parameters[i];j++)
159             out<<Judge[i][j];
160         out<<endl;
161     }
162     }
163  }
164     return 0;
165 }
166 
167 void Random_build1(int parameters_num,int rangeof_count,int i)
168 {
169     int parameters;
170     int fuhao=0;
171     stringstream ss;
172     //随机产生 运算表达数
173     parameters=0+rand()%rangeof_count;
174     //判断上一次产生的是否除法
175     if(fuhao==3)
176     {
177        while(parameters==0)     //除数为0就重新生成
178         {
179             parameters=0+rand()%rangeof_count;
180         }
181     }
182     //随机产生 运算符(最后一次不产生运算符)
183     if(i<parameters_num)
184     {
185         fuhao=((0+rand()%4)+4)%4;
186     }
187     if(i<parameters_num)
188     {
189         //将产生的数放入判断重复的数组中
190         ss<<parameters;
191         ss>>Judge[row][ran];
192         ran++;    //列增加
193         Judge[row][ran]=op_arrays[fuhao];
194         ran++;    //列增加
195     }
196     else 
197     {
198         ss<<parameters;
199         ss>>Judge[row][ran];
200     }
201 }
202 
203 void Random_build2(int parameters_num,int rangeof_count,int i)
204 {
205     int parameters;
206     int fuhao;
207     stringstream ss;
208     //随机产生 运算表达数
209     parameters=0+rand()%rangeof_count;
210 
211     //随机产生 运算符(最后一次不产生运算符)
212     if(i<parameters_num)
213     {
214          fuhao=((0+rand()%2)+2)%2;
215     }
216     if(i<parameters_num)
217     {
218         //将产生的数放入判断重复的数组中
219         ss<<parameters;
220         ss>>Judge[row][ran];
221         ran++;    //列增加
222         Judge[row][ran]=op_arrays[fuhao];
223         ran++;    //列增加
224     }
225     else 
226     {
227         ss<<parameters;
228         ss>>Judge[row][ran];
229     }
230 }
231 
232 void Random_build3(int parameters_num,int rangeof_count,int i)
233 {
234     int parameters;
235     int fuhao;
236     stringstream ss;
237     //随机产生 运算表达数
238     parameters=0+rand()%rangeof_count;
239 
240     //随机产生 运算符(最后一次不产生运算符)
241     if(i<parameters_num)
242     {
243          fuhao=((0+rand()%2)+2)%2;
244     }
245     if(i<parameters_num)
246     {
247         //将产生的数以字符放入判断重复的数组中
248         ss<<parameters;
249         ss>>para[k];
250         k++;    //列增加
251 
252         para[k]=op_arrays[fuhao];
253         k++;    //列增加
254     }
255     else 
256     {
257         ss<<parameters;
258         ss>>para[k];
259     }
260 }
261 
262 void Random_build4(int parameters_num,int rangeof_count,int i)
263 {
264     int parameters;
265     int fuhao=0;
266     stringstream ss;
267     //随机产生 运算表达数
268     parameters=0+rand()%rangeof_count;
269     if(fuhao==3)
270     {
271        while(parameters==0)     //除数为0就重新生成
272         {
273             parameters=0+rand()%rangeof_count;
274         }
275     }
276     //随机产生 运算符(最后一次不产生运算符)
277     if(i<parameters_num)
278     {
279          fuhao=((0+rand()%4)+4)%4;
280     }
281     if(i<parameters_num)
282     {
283         //将产生的数以字符放入判断重复的数组中
284         ss<<parameters;
285         ss>>para[k];
286         k++;    //列增加
287 
288         para[k]=op_arrays[fuhao];
289         k++;    //列增加
290     }
291     else 
292     {
293         ss<<parameters;
294         ss>>para[k];
295     }
296 }
297 
298 void Decu(int l,int s,int flag)
299 {
300     //srand(time(NULL));//用系统当前时间设置rand()随机序列种子，保证每次运行随机序列不一样
301 
302     if((s-l)<2) return ;
303 
304     if((s-l)==2)
305     {
306         if(flag==1)
307         {
308             //产生括号
309           Judge[row][ran]="(";
310           ran++;
311           Judge[row][ran]=para[l];
312           ran++;
313           Judge[row][ran]=para[l+1];
314           ran++;
315           Judge[row][ran]=para[s];
316           ran++;
317           Judge[row][ran]=")";
318           ran++;
319         }
320         if(flag==0)
321         {
322           Judge[row][ran]=para[l];
323           ran++;
324           Judge[row][ran]=para[l+1];
325           ran++;
326           Judge[row][ran]=para[s];
327           ran++;
328         }
329         return ;
330     }
331     if((s-l)==4)
332     {
333         //存在随机数个数为奇数的情况
334         flag=0+rand()%2;
335         if(flag==1)
336         {
337          Judge[row][ran]="(";
338          ran++;
339          Judge[row][ran]=para[l];
340          ran++;
341          Judge[row][ran]=para[l+1];
342          ran++;
343          flag=0+rand()%2;
344          Decu(l+2,s,flag);
345          Judge[row][ran]=")";
346           ran++;
347         }
348         if(flag==0)
349         {
350              Judge[row][ran]=para[l];
351          ran++;
352          Judge[row][ran]=para[l+1];
353          ran++;
354          flag=0+rand()%2;
355          Decu(l+2,s,flag);
356         }
357           return ;
358     }
359 
360     if((s-l)>4)
361     {
362             flag=0+rand()%2;
363         if(flag==1)
364         {
365          Judge[row][ran]="(";
366          ran++;
367              flag=0+rand()%2;
368          Decu(l,s-4,flag);
369          Judge[row][ran]=para[s-3];
370          ran++;
371          l=s-2;
372          flag=0+rand()%2;
373          Decu(l,s,flag);
374          Judge[row][ran]=")";
375           ran++;
376         }
377         if(flag==0)
378         {
379             flag=0+rand()%2;
380          Decu(l,s-4,flag);
381          Judge[row][ran]=para[s-3];
382          ran++;
383          l=s-2;
384          flag=0+rand()%2;
385          Decu(l,s,flag);
386         }
387           return ;
388     }
389 }

运行截图：

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
	在括号数量多以后数组存放有问题，目前还未解决