zoukankan      html  css  js  c++  java
  • 四则运算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] << "=" << endl; break;
    317                     case 1:
    318                         cout << A[i] << " - " << B[i] << "=" << endl; break;
    319                     }
    320                 }
    321                 else
    322                 {
    323                     int copyA = A[i];
    324                     int copyB = B[i];
    325                     int beichushuA = maxfigure;
    326                     int beichushuB = maxfigure;
    327                     int firstA = beichushuA% copyA;
    328                     int firstB = beichushuB% copyB;
    329                     while (firstA != 0)
    330                     {
    331                         int temp = copyA;
    332                         copyA = beichushuA%copyA;
    333                         beichushuA = temp;
    334                         firstA = beichushuA%copyA;
    335                     }
    336                     while (firstB != 0)
    337                     {
    338                         int temp = copyB;
    339                         copyB = beichushuB%copyB;
    340                         beichushuB = temp;
    341                         firstB = beichushuB%copyB;
    342                     }
    343                     int suanfu = rand() % 2;
    344                     switch (suanfu)
    345                     {
    346                     case 0:
    347                         cout << A[i] / copyA << "/" << maxfigure / copyA << " + " << B[i] / copyB << "/" << maxfigure / copyB << "=" << endl; break;
    348                     case 1:
    349                         cout << B[i] / copyB << "/" << maxfigure / copyB << " - " << A[i] / copyA << "/" << maxfigure / copyA << "=" << endl; break;
    350                     }
    351                 }
    352             }
    353         }
    354     }
    355     else  //将最后生成的四则运算式存到文件中,内部实现的功能与输出到屏幕一致,只是输出不一样
    356     {
    357         if (1 == chengchu)
    358         {
    359             if (remainder_chengchu)
    360             {
    361                 ofstream fileout;  //定义输出文件流的对象
    362                 fileout.open("biaodashi.txt", ios::out);  //打开文件,该文件为指定路径,则存放在工程的当前目录下
    363                 fileout << "*******************************************************************" << endl;
    364                 fileout << "生成的四则运算式如下所示:" << endl;
    365                 fileout << "*******************************************************************" << endl;
    366                 for (i = 0; i < count; i++)
    367                 {
    368                     if (A[i] > B[i])
    369                     {
    370                         int m;
    371                         int operator_count = 3 + rand() % 8;
    372                         int operatorfu_count = operator_count - 1;
    373                         for (m = 0; m < operator_count; m++)
    374                         {
    375                             Operator[m] = minfigure + rand() % maxfigure;
    376                         }
    377                         for (m = 0; m < operatorfu_count; m++)
    378                         {
    379                             Operatorfu[m] = rand() % 4;
    380                         }
    381                         for (m = 1; m < operator_count; m++)
    382                         {
    383                             if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
    384                             {
    385                                 switch (Operatorfu[m - 1])
    386                                 {
    387                                 case 0:
    388                                     fileout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
    389                                 case 1:
    390                                     fileout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
    391                                 case 2:
    392                                     fileout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
    393                                 case 3:
    394                                     if (0 == Operator[m])
    395                                     {
    396                                         fileout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
    397                                     }
    398                                     break;
    399                                 }
    400                                 switch (Operatorfu[m])
    401                                 {
    402                                 case 0:
    403                                     fileout << " + "; m = m + 1; break;
    404                                 case 1:
    405                                     fileout << " - "; m = m + 1; break;
    406                                 case 2:
    407                                     fileout << " x "; m = m + 1; break;
    408                                 case 3:
    409                                     fileout << " ÷ "; m = m + 1; break;
    410                                 }
    411                             }
    412                             else
    413                             {
    414                                 switch (Operatorfu[m - 1])
    415                                 {
    416                                 case 0:
    417                                     fileout << Operator[m - 1] << " + "; break;
    418                                 case 1:
    419                                     fileout << Operator[m - 1] << " - "; break;
    420                                 case 2:
    421                                     fileout << Operator[m - 1] << " x "; break;
    422                                 case 3:
    423                                     fileout << Operator[m - 1] << " ÷ "; break;
    424                                 }
    425                             }
    426                         }
    427                         fileout << Operator[m - 1] << " = " << endl;
    428                     }
    429                     else
    430                     {
    431                         int copyA = A[i];
    432                         int copyB = B[i];
    433                         int beichushuA = maxfigure;
    434                         int beichushuB = maxfigure;
    435                         int firstA = beichushuA% copyA;
    436                         int firstB = beichushuB% copyB;
    437                         while (firstA != 0)
    438                         {
    439                             int temp = copyA;
    440                             copyA = beichushuA%copyA;
    441                             beichushuA = temp;
    442                             firstA = beichushuA%copyA;
    443                         }
    444                         while (firstB != 0)
    445                         {
    446                             int temp = copyB;
    447                             copyB = beichushuB%copyB;
    448                             beichushuB = temp;
    449                             firstB = beichushuB%copyB;
    450                         }
    451                         int suanfu = rand() % 4;
    452                         switch (suanfu)
    453                         {
    454                         case 0:
    455                             fileout << A[i] / copyA << "/" << maxfigure / copyA << " + " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
    456                         case 1:
    457                             fileout << A[i] / copyA << "/" << maxfigure / copyA << " - " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
    458                         case 2:
    459                             fileout << A[i] / copyA << "/" << maxfigure / copyA << " x " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
    460                         case 3:
    461                             fileout << A[i] / copyA << "/" << maxfigure / copyA << " ÷ " << B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
    462                         }
    463                     }
    464                 }
    465                 fileout.close();   //关闭文件,断开与文件连接
    466             }
    467             else
    468             {
    469                 ofstream fileout;
    470                 fileout.open("biaodashi.txt", ios::out);
    471                 fileout << "*******************************************************************" << endl;
    472                 fileout << "生成的四则运算式如下所示:" << endl;
    473                 fileout << "*******************************************************************" << endl;
    474                 for (i = 0; i < count; i++)
    475                 {
    476                     if (A[i] > B[i])
    477                     {
    478                         int m;
    479                         int operator_count = 3 + rand() % 8;
    480                         int operatorfu_count = operator_count - 1;
    481                         for (m = 0; m < operator_count; m++)
    482                         {
    483                             Operator[m] = minfigure + rand() % maxfigure;
    484                         }
    485                         for (m = 0; m < operatorfu_count; m++)
    486                         {
    487                             Operatorfu[m] = rand() % 4;
    488                         }
    489                         for (m = 1; m < operator_count; m++)
    490                         {
    491                             if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
    492                             {
    493                                 switch (Operatorfu[m - 1])
    494                                 {
    495                                 case 0:
    496                                     fileout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
    497                                 case 1:
    498                                     fileout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
    499                                 case 2:
    500                                     fileout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
    501                                 case 3:
    502                                     if (0 == Operator[m])
    503                                     {
    504                                         fileout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
    505                                     }
    506                                     break;
    507                                 }
    508                                 switch (Operatorfu[m])
    509                                 {
    510                                 case 0:
    511                                     fileout << " + "; m = m + 1; break;
    512                                 case 1:
    513                                     fileout << " - "; m = m + 1; break;
    514                                 case 2:
    515                                     fileout << " x "; m = m + 1; break;
    516                                 case 3:
    517                                     fileout << " ÷ "; m = m + 1; break;
    518                                 }
    519                             }
    520                             else
    521                             {
    522                                 switch (Operatorfu[m - 1])
    523                                 {
    524                                 case 0:
    525                                     fileout << Operator[m - 1] << " + "; break;
    526                                 case 1:
    527                                     fileout << Operator[m - 1] << " - "; break;
    528                                 case 2:
    529                                     fileout << Operator[m - 1] << " x "; break;
    530                                 case 3:
    531                                     fileout << Operator[m - 1] << " ÷ "; break;
    532                                 }
    533                             }
    534                         }
    535                         fileout << Operator[m - 1] << " = " << endl;
    536                     }
    537                     else
    538                     {
    539                         int copyB = B[i];
    540                         int first = B[i] % A[i];
    541                         while (first != 0)
    542                         {
    543                             int temp = A[i];
    544                             A[i] = B[i] % A[i];
    545                             B[i] = temp;
    546                             first = B[i] % A[i];
    547                         }
    548                         int suanfu = rand() % 4;
    549                         switch (suanfu)
    550                         {
    551                         case 0:
    552                             fileout << A[i] << " + " << B[i] << "=" << endl; break;
    553                         case 1:
    554                             fileout << A[i] << " - " << B[i] << "=" << endl; break;
    555                         case 2:
    556                             fileout << A[i] << " x " << B[i] << "=" << endl; break;
    557                         case 3:
    558                             fileout << copyB << " ÷ " << A[i] << " = " << endl; break;
    559                         }
    560                     }
    561                 }
    562                 fileout.close();
    563             }
    564         }
    565         else
    566         {
    567             if ((minfigure < 0) && (0 == negative_jiajian))
    568             {
    569                 cout << "请重新设置数值范围,最小值应大于零以保证加法无负数!" << endl;
    570                 cout << "请输入参与四则运算的数值范围(格式如:1  100):";
    571                 cin >> minfigure >> maxfigure;
    572                 for (i = 0; i < count; i++)
    573                 {
    574                     A[i] = minfigure + rand() % maxfigure;
    575                     B[i] = minfigure + rand() % maxfigure;
    576                     for (j = 0; j < i; j++)
    577                     {
    578                         if (A[i] == A[j])
    579                         {
    580                             A[i] = minfigure + rand() % maxfigure;
    581                             j = 0;
    582                         }
    583                         if (B[i] == B[j])
    584                         {
    585                             B[i] = minfigure + rand() % maxfigure;
    586                             j = 0;
    587                         }
    588                     }
    589                 }
    590             }
    591             ofstream fileout;
    592             fileout.open("biaodashi.txt", ios::out);
    593             for (i = 0; i < count; i++)
    594             {
    595                 if (A[i]>B[i])
    596                 {
    597                     int suanfu = rand() % 2;
    598                     switch (suanfu)
    599                     {
    600                     case 0:
    601                         fileout << A[i] << " + " << B[i] << "=" << endl; break;
    602                     case 1:
    603                         fileout << A[i] << " - " << B[i] << "=" << endl; break;
    604                     }
    605                 }
    606                 else
    607                 {
    608                     int copyA = A[i];
    609                     int copyB = B[i];
    610                     int beichushuA = maxfigure;
    611                     int beichushuB = maxfigure;
    612                     int firstA = beichushuA% copyA;
    613                     int firstB = beichushuB% copyB;
    614                     while (firstA != 0)
    615                     {
    616                         int temp = copyA;
    617                         copyA = beichushuA%copyA;
    618                         beichushuA = temp;
    619                         firstA = beichushuA%copyA;
    620                     }
    621                     while (firstB != 0)
    622                     {
    623                         int temp = copyB;
    624                         copyB = beichushuB%copyB;
    625                         beichushuB = temp;
    626                         firstB = beichushuB%copyB;
    627                     }
    628                     int suanfu = rand() % 2;
    629                     switch (suanfu)
    630                     {
    631                     case 0:
    632                         fileout << A[i] / copyA << "/" << maxfigure / copyA << " + " << B[i] / copyB << "/" << maxfigure / copyB << "=" << endl; break;
    633                     case 1:
    634                         fileout << B[i] / copyB << "/" << maxfigure / copyB << " - " << A[i] / copyA << "/" << maxfigure / copyA << "=" << endl; break;
    635                     }
    636                 }
    637             }
    638             fileout.close();
    639         }
    640     }
    641 }

        运行结果截图如下所示:

       

       

       

       

       

        项目计划总结表:

    周活动总结表                      日期:2016年3月12日
    日期任务 听课 编写程序 阅读课本 日总结
    周一 3.7 2 1 1 4
    周二 3.8        
    周三 3.9   2 1 3
    周四 3.10 2   1 3
    周五 3.11   3   3
    周六 3.12   8   8
    周日 3.13        
    周总计 4 14 3 21

        时间记录日志:   

    日期 开始时间 结束时间 中断时间 净时间 活动 备注
    3.7 14:00 16:00   2 听课,改程序  
      20:00 21:00   1 看课本  
      21:20 22:20   1 写程序  
    3.8            
    3.9 14:30 18:00 0.5 3 写程序,看课本 洗衣服
    3.10 19:00 22:00   3 上课,看书  
    3.11 19:00 22:00   3 写程序  
    3.12 8:00 12:00   4 写程序  
      13:00 17:00   4 写程序  
    3.13            

        缺陷记录日志:

    日期 编号 类型 引入阶段 排除阶段 修复时间 修复缺陷
    3.7 1   编译 编译 5min  
    描述:for循环中的循环条件不对
    3.8            
               
    3.9 2   编码 编码 1min  
    描述:if和else不匹配
    3.10            
               
    3.11 3   编码 编码 2h  
    描述:主程序逻辑结构不正确
    3.12 4   编码 编码 3h  
    描述:逻辑功能嵌套不完善

       

       

  • 相关阅读:
    超简单实例使用websocket进行server和client实时通信
    antd的table行key自增长
    selenium元素定位Xpath,Contains,CssSelector
    slenium使用鼠标+键盘事件或者双击实现代码
    使用python+pychram进行API测试(接口测试)初级STEP 1
    linux命令小常识
    sql中limit使用方法
    Swagger-API测试工具实战
    写 test-case心得
    测试之路之[前奏]
  • 原文地址:https://www.cnblogs.com/hulidanxiang/p/5269460.html
Copyright © 2011-2022 走看看