四则运算2开发简介

Posted 鹄立丹香

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了四则运算2开发简介相关的知识,希望对你有一定的参考价值。

    四则运算2在四则运算1的基础之上,又添加了新的功能,但是我觉得四则运算2的难度比四则运算1增大了很多,我在编程的过程中,遇到的最大难度就是不知该如何更好的融合各个功能之间的关系。

    写到现在,四则运算2主要实现了以下几个功能:

    1.题目可不重复

    2.打印方式可以选择,既可以在屏幕上输出,又可以保存到文件

    3.题目的数量可以由用户控制

    4.可以设置四则运算的数值范围

    5.可以实现运算式中有无乘除法

    6.可以支持十个数参与运算,并且通过括号改变运算的优先级

    7.有除法算式的情况下,可以实现整数除法的整除运算,不产生余数

    8.加减法可以实现无负数参与运算

    根据程序实现的功能,对程序的设计思想简介如下:

    1.为保证题目的不重复,在产生随机数时加入了判断语句,将当下产生的随机数与以前产生的随机数作比较,如果重复了,则当下的随机数舍弃,重新生成,重新生成后接着比较,直到产生新的不重复的随机数才继续往下执行。

    2.打印方式分为在屏幕上输出与保存至文件两项,保存到文件的程序功能与输出到屏幕的程序功能一致,在输出到文件时,定义了一个txt文档,用文件输出流将最后的结果输出到文件保存。

    3.程序开始会让用户设置某些参数,通过定义全局变量的形式,保存用户输入的运算式数量,从而控制产生的运算式数量。

    4.设置数值范围与设置数量的方式一样,也定义了全局变量。

    5.乘除法的实现是用随机数控制的,只产生0和1两个随机数,再加上switch语句就可以实现只有加减两种运算。

    6.利用随机函数生成3-10的一个随机数,这个随机数代表了多项式四则运算中的因子个数,然后分别产生这些随机数和比运算数少一的运算符,比较后一个运算符和前一个运算符的优先级,若后一个运算符的优先级比前一个高,即后面的运算为乘除,则将前一个算式用括号括起来,保证了加减运算可以实现。

    7.多项式运算没有实现没有余数,两个整数参与运算时,可以保证整除,分数除法考虑是否能够整除无意义

    8.当数值范围定义中含有负数范围时,程序会提示用户再次输入范围,即若最小值小于零,则不能保证每一个加数都是大于零的,则需用户再次输入范围,重新生成随机数。

    程序源代码如下所示:

  1 //四则运算程序2,从四则运算程序1的基础之上进行功能扩展
  2 //支持真分数运算,题目不重复,最多可支持十个运算数的带括号的运算式
  3 //多项四则运算式以及分数除法未予考虑余数,整数除法可以实现整除功能
  4 //2016,03,09
  5 
  6 #include<iostream>
  7 #include<fstream>
  8 #include<stdlib.h>
  9 #include<time.h>
 10 using namespace std;
 11 
 12 void main()
 13 {
 14     srand((int)time(NULL));
 15     //定义变量,记录用户的功能选择选项
 16     int minfigure;
 17     int maxfigure;
 18     int count;
 19     int chengchu;
 20     int remainder_chengchu;
 21     int negative_jiajian;
 22     int printstyle;
 23     //功能设置界面
 24     cout << "*******************************************************************" << endl;
 25     cout << "*                         四则运算生成器                          *" << endl;
 26     cout << "*******************************************************************" << endl;
 27     cout << "请按照系统提示设置生成器的功能:" << endl;
 28     cout << "请输入参与四则运算的数值范围(格式如:1  100):" ;
 29     cin >> minfigure >> maxfigure;
 30     cout << "请输入生成四则运算式的数量:";
 31     cin >> count;
 32     cout << "请选择打印方式(1 屏幕输出  0 输出到文档):";
 33     cin >> printstyle;
 34     cout << "请设置系统的下列参数:" << endl;
 35     cout << "    1 四则运算可否生成乘除法(1 是  0 否):";
 36     cin >> chengchu;
 37     if (1 == chengchu)
 38     {
 39         cout << "    2 除法是否可有余数(1 是  0 否):";
 40         cin >> remainder_chengchu;
 41     }
 42     else
 43     {
 44         cout << "    2 加减法是否可以有负数(1 是  0 否):";
 45         cin >> negative_jiajian;
 46     }
 47     cout << "功能设置完成!" << endl;
 48     cout << "*******************************************************************" << endl;
 49 
 50     int i, j;
 51     int A[100];
 52     int B[100];
 53     int mark[9];
 54     int Operator[10];
 55     char operatorFu[9];
 56     int Operatorfu[9];
 57     //生成用户指定数量的运算式的因子,为保证算式不重复,让生成的随机数都不重复
 58     for (i = 0; i < count; i++)
 59     {
 60         A[i] = minfigure + rand() % maxfigure;
 61         B[i] = minfigure + rand() % maxfigure;
 62         for (j = 0; j < i; j++)
 63         {
 64             if (A[i] == A[j])
 65             {
 66                 A[i] = minfigure + rand() % maxfigure;
 67                 j = 0;
 68             }
 69             if (B[i] == B[j])
 70             {
 71                 B[i] = minfigure + rand() % maxfigure;
 72                 j = 0;
 73             }
 74         }
 75     }
 76     //根据用户的选择产生功能分支
 77     if (1 == printstyle)   //运算式输出到屏幕上
 78     {
 79         if (1 == chengchu)  //是否可以生成除法
 80         {
 81             if (remainder_chengchu)  //除法可否有余数,分数除法谈论是否有余数无意义
 82             {
 83                 cout << "*******************************************************************" << endl;
 84                 cout << "生成的四则运算式如下所示:" << endl;
 85                 cout << "*******************************************************************" << endl;
 86                 for (i = 0; i < count; i++)
 87                 {
 88                     if (A[i] > B[i])   //如果A[i]>B[i],则后续程序生成带括号的多项因子的四则运算
 89                     {
 90                         int m;
 91                         int operator_count = 3 + rand() % 8;   //随机生成多项因子的个数
 92                         int operatorfu_count = operator_count - 1;  //算符的个数比因子的个数少一
 93                         for (m = 0; m < operator_count; m++)
 94                         {
 95                             Operator[m] = minfigure + rand() % maxfigure;   //生成多项因子
 96                         }
 97                         for (m = 0; m < operatorfu_count; m++)
 98                         {
 99                             Operatorfu[m] = rand() % 4;                  //生成多项式的算符
100                         }
101                         for (m = 1; m < operator_count; m++)
102                         {
103                             if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))  //乘除用3和4表示,加减用1和2表示,让其除以二得商0和1,可以区分出乘除为同一优先级,加减比乘除优先级低
104                             {                                                 //若后一个运算符的优先级比前一个运算符的优先级高,则将前一个运算符对应的式子用括号括起来,确保了运算优先级低的加减运算在括号里面
105                                 switch (Operatorfu[m - 1])
106                                 {
107                                 case 0:
108                                     cout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
109                                 case 1:
110                                     cout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
111                                 case 2:
112                                     cout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
113                                 case 3:
114                                     if (0 == Operator[m])
115                                     {
116                                         cout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
117                                     }
118                                     break;   //若分子为零时,则让分子加2,即除以2
119                                 }
120                                 switch (Operatorfu[m])
121                                 {
122                                 case 0:
123                                     cout << " + "; m = m + 1; break;
124                                 case 1:
125                                     cout << " - "; m = m + 1; break;
126                                 case 2:
127                                     cout << " x "; m = m + 1; break;
128                                 case 3:
129                                     cout << " ÷ "; m = m + 1; break;
130                                 }
131                             }
132                             else
133                             {
134                                 switch (Operatorfu[m - 1])
135                                 {
136                                 case 0:
137                                     cout << Operator[m - 1] << " + "; break;
138                                 case 1:
139                                     cout << Operator[m - 1] << " - "; break;
140                                 case 2:
141                                     cout << Operator[m - 1] << " x "; break;
142                                 case 3:
143                                     cout << Operator[m - 1] << " ÷ "; break;
144                                 }
145                             }
146                         }
147                         cout << Operator[m - 1] << " = " << endl;         //输出最后一个多项式因子
148                     }
149                     else            //如果A[i]<B[i],则产生真分数运算式
150                     {
151                         int copyA = A[i];
152                         int copyB = B[i];
153                         int beichushuA = maxfigure;
154                         int beichushuB = maxfigure;
155                         int firstA = beichushuA% copyA;
156                         int firstB = beichushuB% copyB;
157                         while (firstA != 0)        //求A[i]和最大值的公约数,以便后面化简
158                         {
159                             int temp = copyA;
160                             copyA = beichushuA%copyA;
161                             beichushuA = temp;
162                             firstA = beichushuA%copyA;
163                         }
164                         while (firstB != 0)
165                         {
166                             int temp = copyB;
167                             copyB = beichushuB%copyB;
168                             beichushuB = temp;
169                             firstB = beichushuB%copyB;
170                         }
171                         int suanfu = rand() % 4;
172                         switch (suanfu)
173                         {
174                         case 0:
175                             cout << A[i] / copyA << "/" << maxfigure / copyA << " + " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
176                         case 1:
177                             cout << A[i] / copyA << "/" << maxfigure / copyA << " - " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
178                         case 2:
179                             cout << A[i] / copyA << "/" << maxfigure / copyA << " x " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
180                         case 3:
181                             cout << A[i] / copyA << "/" << maxfigure / copyA << " ÷ " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
182                             //让A[i]和最大值都除以公约数便可以得到无法再约分的最大公约数
183                         }
184                     }
185                 }
186             }
187             else
188             {
189                 cout << "*******************************************************************" << endl;
190                 cout << "生成的四则运算式如下所示:" << endl;
191                 cout << "*******************************************************************" << endl;
192                 for (i = 0; i < count; i++)
193                 {
194                     if (A[i] > B[i])
195                     {
196                         int m;
197                         int operator_count = 3 + rand() % 8;
198                         int operatorfu_count = operator_count - 1;
199                         for (m = 0; m < operator_count; m++)
200                         {
201                             Operator[m] = minfigure + rand() % maxfigure;
202                         }
203                         for (m = 0; m < operatorfu_count; m++)
204                         {
205                             Operatorfu[m] = rand() % 4;
206                         }
207                         for (m = 1; m < operator_count; m++)
208                         {
209                             if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
210                             {
211                                 switch (Operatorfu[m - 1])
212                                 {
213                                 case 0:
214                                     cout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
215                                 case 1:
216                                     cout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
217                                 case 2:
218                                     cout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
219                                 case 3:
220                                     if (0 == Operator[m])
221                                     {
222                                         cout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
223                                     }
224                                     break;
225                                 }
226                                 switch (Operatorfu[m])
227                                 {
228                                 case 0:
229                                     cout << " + "; m = m + 1; break;
230                                 case 1:
231                                     cout << " - "; m = m + 1; break;
232                                 case 2:
233                                     cout << " x "; m = m + 1; break;
234                                 case 3:
235                                     cout << " ÷ "; m = m + 1; break;
236                                 }
237                             }
238                             else
239                             {
240                                 switch (Operatorfu[m - 1])
241                                 {
242                                 case 0:
243                                     cout << Operator[m - 1] << " + "; break;
244                                 case 1:
245                                     cout << Operator[m - 1] << " - "; break;
246                                 case 2:
247                                     cout << Operator[m - 1] << " x "; break;
248                                 case 3:
249                                     cout << Operator[m - 1] << " ÷ "; break;
250                                 }
251                             }
252                         }
253                         cout << Operator[m - 1] << " = " << endl;
254                     }
255                     else
256                     {
257                         int copyB = B[i];
258                         int first = B[i] % A[i];
259                         while (first != 0)
260                         {
261                             int temp = A[i];
262                             A[i] = B[i] % A[i];
263                             B[i] = temp;
264                             first = B[i] % A[i];
265                         }
266                         int suanfu = rand() % 4;
267                         switch (suanfu)
268                         {
269                         case 0:
270                             cout << A[i] << " + " << B[i] << "=" << endl; break;
271                         case 1:
272                             cout << A[i] << " - " << B[i] << "=" << endl; break;
273                         case 2:
274                             cout << A[i] << " x " << B[i] << "=" << endl; break;
275                         case 3:
276                             cout << copyB << " ÷ " << A[i] << " = " << endl; break;
277                         }
278                     }
279                 }
280             }
281         }
282         else   //不允许生成乘除法,则只有加减法
283         {
284             if ((minfigure < 0) && (0 == negative_jiajian))  //若加减法不允许出现负数,则应该重新设定数值的范围,让最小值大于零,保证生成的随机数都是大于零的
285             {
286                 cout << "请重新设置数值范围,最小值应大于零以保证加法无负数!" << endl;
287                 cout << "请输入参与四则运算的数值范围(格式如:1  100):";
288                 cin >> minfigure >> maxfigure;
289                 for (i = 0; i < count; i++)     //重新生成的随机数仍是不重复的
290                 {
291                     A[i] = minfigure + rand() % maxfigure;
292                     B[i] = minfigure + rand() % maxfigure;
293                     for (j = 0; j < i; j++)
294                     {
295                         if (A[i] == A[j])
296                         {
297                             A[i] = minfigure + rand() % maxfigure;
298                             j = 0;
299                         }
300                         if (B[i] == B[j])
301                         {
302                             B[i] = minfigure + rand() % maxfigure;
303                             j = 0;
304                         }
305                     }
306                 }
307             }
308             for (i = 0; i < count; i++)
309             {
310                 if (A[i]>B[i])
311                 {
312                     int suanfu = rand() % 2;
313                     switch (suanfu)
314                     {
315                     case 0:
316                         cout << A[i] << " + " << B[i] << "=" <

以上是关于四则运算2开发简介的主要内容,如果未能解决你的问题,请参考以下文章

四则运算2开发简介

Android 逆向Linux 文件权限 ( Linux 权限简介 | 系统权限 | 用户权限 | 匿名用户权限 | 读 | 写 | 执行 | 更改组 | 更改用户 | 粘滞 )(代码片段

Android 逆向类加载器 ClassLoader ( 类加载器源码简介 | BaseDexClassLoader | DexClassLoader | PathClassLoader )(代码片段

在PaddlePaddle中的Notebook代码片段

SpringCloud系列十一:SpringCloudStream(SpringCloudStream 简介创建消息生产者创建消息消费者自定义消息通道分组与持久化设置 RoutingKey)(代码片段

C#-WebForm-★内置对象简介★Request-获取请求对象Response相应请求对象Session全局变量(私有)Cookie全局变量(私有)Application全局公共变量Vi(代码片段