时间比较紧，我简单写写我的设计思路：
题目在四则运算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;
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 | |
| 周二 | 0 | 200 | 0 | |
| 周三 | 0 | 180 | 0 | |
| 周四 | 100 | 200 | 80 | |
| 周五 | 0 | 200 | 60 | |
| 周六 | 0 | 300 | 60 | |
| 周日 | ||||
| 周总计 | 200 |
时间记录日志：
| 日期 | 开始时间 | 结束时间 | 中断时间 | 净时间 | 活动 | 备注 |
| 7/3 | 14:00 | 15:50 | ||||
| 8/3 | ||||||
| 9/3 | ||||||
| 10/3 | ||||||
| 11/3 | ||||||
| 12/3 |
时间： 2024-10-11 17:42:24