zoukankan      html  css  js  c++  java

  • 四则运算3

    老师提出了新的要求：

       1、学生写的程序必须能判定用户的输入答案是否正确， 

     　　例如程序输出：20 – 5 = ?用户输入15，那么程序就会反馈正确，然后继续出题。直  到 30 道题目结束，程序最后告诉用户作对了几道题。

       2、程序必须能处理四种运算的混合算式；

    　　20 – 5 * 2 =？           正确答案是10.

    　　20– 5 * 2 + 9 / 3 = ？   正确答案是13

    注意：

    　　连续的减法和除法，应该遵守左结合的规定。

    　　连续除法要打括号，否则会引起歧义

    设计思路（简要）：

    将程序分成两大部分：简单二元四则运算，复杂多元四则运算

    简单二元四则运算：

    简单二元四则运算中实现大部分的要求。

    复杂多元运算：

    定义结构体ComplexOperation，结构体中有两个整型，一个用于存储数，另一个用于判断括号，用结构体定义数组num[10]。定义数组fuhao[10]用于存储运算符，随机生成运算数个数，在随机生成运算符（数目比运算数少一）。使用if语句判断符号中是否出现连续的除法，如果是则将表示括号的整数改成相对应的数。在定义一个整型result保存结果，函数getResult（）返回结果。

    结果的得出，for（int i=0;i<运算数；i++）语句循环，循环体判断运算符是否除号还是乘号，将对应位置的运算数进行相应的运算，并将结果存储到第一个数所在的位置，然后将后面的数向前移一位，长度减一。在使用类似的循环计算加减。最后结果存储在数组的一号位置。

    Main：

    首先判断是哪种运算：简单还是复杂，简单，在设定多种条件。

    设定一个数组，存储用户每次输入的结果。用户输入时，判断用户输入的格式，格式不对，重新输入。

    设定循环30次，在每次循环中先输出运算式子，再让用户输入结果，将用户的结果与正确结果比较，对，则将计数的整数++。最后输出答对题目数

    源代码：

    ErYuan.h：

     1 #pragma once
 2 #include<iostream>
 3 using namespace std;
 4 class ErYuan
 5 {
 6 public:
 7     ErYuan(void);
 8     ~ErYuan(void);
 9     int setShu();
10     char setHu1();
11     char setHu2();
12     void YueShu(int a,int b);//化简分数
13     //int getResult();
14     void setSimple(int fenshu,int fushu,int chufa,int yushu);
15     void Display1();
16     void Display2();
17     int getYuFenZheng()
18     {
19         return yu_fen_zheng;
20     }
21     int getDaZi()
22     {
23         return da_zi;
24     }
25     int getYuMu()
26     {
27         return yu_mu;
28     }
29 private:
30     
31     int shu1,shu2,shu3,shu4;//结果为整数，除法必须整除
32     char fu;
33     int zi,mu;
34     int yu_fen_zheng,da_zi,yu_mu;//yu_fen_zheng代表数据类型，0：整 1：分 2：余
35     //da_zi代表整数答案或分子，yu_mu代表余数或分母
36 };
    View Code

      ErYuan.cpp：

      1 #include "ErYuan.h"
  2 #include<time.h>
  3 
  4 ErYuan::ErYuan(void)
  5 {
  6 }
  7 
  8 
  9 ErYuan::~ErYuan(void)
 10 {
 11 }
 12 int ErYuan::setShu()
 13 {
 14     return rand()%100;
 15 }
 16 char ErYuan::setHu1()
 17 {
 18     int m=rand()%4;
 19     if(m==0)return'+';
 20     else if(m==1)return'-';
 21     else if(m==2)return '*';
 22     else return '/';
 23 }
 24 char ErYuan::setHu2()
 25 {
 26     int m=rand()%2;
 27     if(m==0)return '+';
 28     else return '-';
 29 }
 30 void ErYuan::Display1()/////////////////
 31 {
 32     cout<<shu1<<fu<<shu2<<" ="<<endl;
 33 
 34 }
 35 void ErYuan::Display2()
 36 {
 37     cout<<shu1<<"/"<<shu2<<"  "<<fu<<"  "<<shu3<<"/"<<shu4<<" ="<<endl;
 38 }
 39 void ErYuan::YueShu(int zi,int mu)
 40 {
 41     bool jiaozheng=false;
 42     if(zi<0)
 43         jiaozheng=true;
 44     if(jiaozheng==true)
 45         zi=-zi;
 46     if(zi%mu==0)//整除
 47     {
 48         yu_fen_zheng=0;//整数
 49         da_zi=zi/mu;
 50     }
 51     else
 52     {
 53         int xiao=(zi<mu)?zi:mu;
 54         int max=1;
 55         for(int i=1;i<=xiao;i++)
 56         {
 57             if(zi%i==0&&mu%i==0)
 58                 max=i;
 59         }
 60         yu_fen_zheng=1;//分数
 61         if(jiaozheng==true)
 62             da_zi=-(zi/max);
 63         else
 64             da_zi=zi/max;
 65         yu_mu=mu/max;
 66     }
 67 }
 68 void ErYuan::setSimple(int fenshu,int fushu,int chufa,int yushu)
 69 {
 70     if(fenshu==2)//没有分数
 71     {
 72         shu1=setShu();
 73         shu2=setShu();
 74         if(chufa==2)//没有除法
 75         {
 76             fu=ErYuan::setHu2();
 77             if(fu=='-')
 78             {
 79                 if(fushu==2)//不允许出现负数
 80                     if(shu1<shu2)
 81                     {
 82                         shu3=shu1;
 83                         shu1=shu2;
 84                         shu2=shu3;
 85                     }
 86             }
 87             switch(fu)
 88             {
 89             case('+') :da_zi=shu1+shu2;yu_fen_zheng=0;break;
 90             case('-') :da_zi=shu1-shu2;yu_fen_zheng=0;break;
 91             }
 92         }
 93         else //有除法
 94         {
 95             fu=ErYuan::setHu1();
 96             if(fu=='-')
 97             {
 98                 if(fushu==2)//不允许出现负数
 99                     if(shu1<shu2)
100                     {
101                         shu3=shu1;
102                         shu1=shu2;
103                         shu2=shu3;
104                     }
105                 da_zi=shu1-shu2;yu_fen_zheng=0;
106             }    
107             else if(fu=='/')
108             {
109                 while(shu2==0)
110                 {
111                     shu2=ErYuan::setShu();
112                 }
113                 if(yushu==2)//不允许出现余数
114                 {
115                     if(shu1!=0)
116                     {
117                         shu1=(shu1>shu2)?shu1:shu2;
118                         shu1+=(shu1%shu2);
119                     }
120                     da_zi=shu1/shu2;
121                     yu_fen_zheng=0;
122                 }
123                 else //允许出现余数
124                 {
125                     if(shu1==0)
126                     {
127                         da_zi=0;
128                         yu_fen_zheng=0;
129                     }
130                     else if(shu1%shu2==0)//恰好整除
131                     {
132                         da_zi=shu1/shu2;
133                         yu_fen_zheng=0;
134                     }
135                     else //不能整除
136                     {
137                         yu_fen_zheng=2;//余数
138                         da_zi=shu1/shu2;//整数部分
139                         yu_mu=shu1%shu2;//余数部分
140                     }
141                 }
142             }
143             switch(fu)
144             {
145             case('+') :da_zi=shu1+shu2;yu_fen_zheng=0;break;
146             case('*') :da_zi=shu1*shu2;yu_fen_zheng=0;break;
147             }
148         }
149     }
150     else if(fenshu==1)//有分数
151     {
152         shu2=rand()%9+1;
153         shu1=rand()%shu2;//shu1为shu2的分子
154         shu4=rand()%9+1;
155         shu3=rand()%shu4;//shu3为shu4的分子
156         if(chufa==2)//没有乘除法
157         {
158             fu=ErYuan::setHu2();
159             if(fu=='+')
160             {
161                 zi=shu1*shu4+shu2*shu3;
162                 mu=shu2*shu4;
163                 ErYuan::YueShu(zi,mu);
164             }
165             else if(fu=='-')//减法
166             {
167                 zi=shu1*shu4-shu2*shu3;
168                 mu=shu2*shu4;
169                 ErYuan::YueShu(zi,mu);
170             }
171         }
172         else //有乘除
173         {
174             fu=ErYuan::setHu1();
175             if(fu=='+')
176             {
177                 zi=shu1*shu4+shu2*shu3;
178                 mu=shu2*shu4;
179                 ErYuan::YueShu(zi,mu);
180             }
181             else if(fu=='-')//减法
182             {
183                 zi=shu1*shu4-shu2*shu3;
184                 mu=shu2*shu4;
185                 ErYuan::YueShu(zi,mu);
186             }
187             else if(fu=='*')//乘法
188             {
189                 zi=shu1*shu3;
190                 mu=shu2*shu4;
191                 ErYuan::YueShu(zi,mu);
192             }
193             else//除法
194             {
195                 zi=shu1*shu4;
196                 mu=shu3*shu2;
197                 ErYuan::YueShu(zi,mu);
198             }
199         }
200     }
201 }
    View Code

     DuoYuan.h：

     1 #pragma once
 2 #include<iostream>
 3 using namespace std;
 4 class DuoYuan
 5 {
 6 public:
 7     DuoYuan(void);
 8     ~DuoYuan(void);
 9     void setAll();
10     int getResult();
11     void Display();
12 private:
13     struct ComplexOperation
14     {
15         int num,kuohao;
16     }shu[10];
17     char fuhao[10];
18     int result;
19     int yun_suan_shu;
20 };
    View Code

     DuoYuan.cpp：

      1 #include "DuoYuan.h"
  2 
  3 
  4 DuoYuan::DuoYuan(void)
  5 {
  6 }
  7 
  8 
  9 DuoYuan::~DuoYuan(void)
 10 {
 11 }
 12 
 13 void DuoYuan::setAll()
 14 {
 15     for(int i=0;i<10;i++)
 16     {
 17         shu[i].num=0;
 18         shu[i].kuohao=0;    
 19         fuhao[i]='0';
 20     }
 21     yun_suan_shu=rand()%9+2;
 22     for(int i=0;i<yun_suan_shu;i++)
 23     {
 24         shu[i].num=rand()%10;
 25     }
 26     for(int i=0;i<yun_suan_shu-1;i++)
 27     {
 28         int sui=rand()%4;
 29         if(sui==0) fuhao[i]='+';
 30         else if(sui==1) fuhao[i]='-';
 31         else if(sui==2) fuhao[i]='*';
 32         else fuhao[i]='/';
 33     }
 34 }
 35 void DuoYuan::Display()
 36 {
 37     int count=0;
 38     for(int i=0;i<yun_suan_shu;i++)
 39     {
 40         int j=i;
 41         while(fuhao[i]=='/'&&i<yun_suan_shu)
 42         {
 43             count++;
 44             i++;
 45         }
 46         if(count==1)
 47         {
 48             count=0;
 49             continue; 
 50         }
 51         shu[j].kuohao=count;
 52         for(j;j<i;j++)
 53         {
 54             shu[j+1].kuohao=-1;
 55         }
 56         count=0;
 57     }
 58     for(int i=0;i<yun_suan_shu;i++)
 59     {
 60         if(shu[i].kuohao!=0&&shu[i].kuohao!=-1)
 61         {
 62             while(shu[i].kuohao>0)
 63             {
 64                 cout<<"(";
 65                 shu[i].kuohao--;
 66             }
 67         }
 68         cout<<shu[i].num;
 69         if(shu[i].kuohao==-1)
 70             cout<<")";
 71         if(i!=yun_suan_shu-1)
 72             cout<<fuhao[i];
 73     }
 74     cout<<"=";//<<endl;
 75 }
 76 int DuoYuan::getResult()
 77 {
 78     for(int i=0;i<yun_suan_shu-1;i++)
 79     {
 80         if(fuhao[i]=='*')
 81         {
 82             shu[i].num=shu[i].num*shu[i+1].num;
 83             for(int j=i;j<yun_suan_shu-2;j++)
 84             {
 85                 shu[j+1].num=shu[j+2].num;
 86                 fuhao[j]=fuhao[j+1];
 87             }
 88             yun_suan_shu--;
 89             i--;
 90         }
 91         else if(fuhao[i]=='/')
 92         {
 93             shu[i].num=shu[i].num/shu[i+1].num;
 94             for(int j=i;j<yun_suan_shu-2;j++)
 95             {
 96                 shu[j+1].num=shu[j+2].num;
 97                 fuhao[j]=fuhao[j+1];
 98             }
 99             yun_suan_shu--;
100             i--;
101         }
102     }
103     if(yun_suan_shu!=1)
104     {
105         for(int i=0;i<yun_suan_shu-1;i++)
106         {
107             if(fuhao[i]=='-')
108             {
109                 shu[i].num=shu[i].num-shu[i+1].num;
110                 for(int j=i;j<yun_suan_shu-2;j++)
111                 {
112                     shu[j+1].num =shu[j+2].num;
113                     fuhao[j]=fuhao[j+1];
114                 }
115                 yun_suan_shu--;
116                 i--;
117             }
118             else if(fuhao[i]=='+')
119             {
120                 shu[i].num=shu[i].num+shu[i+1].num;
121                 for(int j=i;j<yun_suan_shu-2;j++)
122                 {
123                     shu[j+1].num =shu[j+2].num;
124                     fuhao[j]=fuhao[j+1];
125                 }
126                 yun_suan_shu--;
127                 i--;
128             }
129         }
130     }
131     result=shu[0].num;
132     return result;
133 }
    View Code

     main：

      1 //陈昌  2016.3.25 四则运算3 20143051
  2 #include"ErYuan.h"
  3 #include"DuoYuan.h"
  4 #include<string>
  5 //#include<stdlib.h>
  6 int getUser()
  7 {
  8     int shuru=0;
  9     bool is_number=false;
 10     string str;
 11     while(!is_number)
 12     {
 13         cin>>str;
 14         //int wei=0;
 15         for(int i=0;i<str.length();i++)
 16         {
 17             if((str[i]>='0'&&str[i]<='9'))
 18             {
 19                 is_number=true;
 20             }
 21             else 
 22             {
 23                 is_number=false;
 24                 cout<<"输入格式错误！请重新输入答案："<<endl;
 25                 break;
 26             }
 27         }
 28     }
 29     shuru=atoi(str.c_str());//将string强制转化为整型
 30     return shuru;
 31 }
 32 int main()
 33 {
 34     ErYuan er;
 35     DuoYuan duo;
 36     int user[30];
 37     int leixing;
 38     int fenshu=2,fushu=2,chufa=2,yushu=2,lie=1;
 39     cout<<"题目类型，1：简单运算，2：复杂运算"<<endl;
 40     cin>>leixing;
 41     if(leixing==1)
 42     {
 43         cout<<"是否需要分数，1:是，2：否"<<endl;
 44         cin>>fenshu;
 45         if(fenshu==2)
 46         {
 47             cout<<"减法是否能出现负数，1：是，2：否"<<endl;
 48             cin>>fushu;
 49         }
 50         cout<<"是否需要乘除法，1：是，2：否"<<endl;
 51         cin>>chufa;
 52         if(chufa==1&&fenshu==2)
 53         {
 54             cout<<"除法是否能有余数,1：是，2：否"<<endl;
 55             cin>>yushu;
 56         }
 57     }
 58     int zheng_que=0;
 59     for(int i=0;i<6;i++)
 60     {
 61         if(leixing==1)
 62         {
 63             er.setSimple(fenshu,fushu,chufa,yushu);
 64             if(fenshu==2)
 65             {
 66                 er.Display1();
 67             }
 68             else if(fenshu==1)
 69                 er.Display2();
 70             int yu_fen_zheng;
 71             yu_fen_zheng=er.getYuFenZheng();
 72             if(yu_fen_zheng==0)
 73             {
 74                 cout<<"请输入答案:  ";
 75                 if(fenshu==2&&yushu==2)//只有当运算为简单运算且没有余数时才保存用户数据
 76                 {
 77                     user[i]=getUser();
 78                     if(user[i]==er.getDaZi())
 79                         zheng_que++;
 80                 }
 81                 else 
 82                 {
 83                     if(getUser()==er.getDaZi())
 84                         zheng_que++;
 85                 }
 86             }
 87             else if(yu_fen_zheng==2)
 88             {
 89                 cout<<"请输入商:";
 90                 int shang;
 91                 shang=getUser();
 92                 cout<<"请输入余数:";
 93                 int yu;
 94                 yu=getUser();
 95                 if(shang==er.getDaZi()&&yu==er.getYuMu())
 96                     zheng_que++;
 97             }
 98             else //分数
 99             {
100                 cout<<"请输入分子：";
101                 int zi;
102                 zi=getUser();
103                 cout<<"请输入分母:";
104                 int mu=getUser();
105                 if(zi==er.getDaZi()&&mu==er.getYuMu())
106                     zheng_que++;
107             }
108         }
109         else
110         {
111             duo.setAll();
112             duo.Display();
113             if(getUser()==duo.getResult())
114             {
115                 zheng_que++;
116             }
117         }
118     }
119     cout<<"正确做对题数： "<<zheng_que<<endl;
120     if(leixing==1&&fenshu==2&&yushu==2)
121     {
122         cout<<"用户输入的答案："<<endl;
123         for(int i=0;i<6;i++)
124         {
125             cout<<user[i]<<"	";
126             if((i+1)%4==0)
127                 cout<<endl;
128         }
129     }
130 }
    View Code

    运行结果截图：

    简单分数运算

    简单无分数运算：

    复杂运算：

    程序总结分析：

    1.截图中只出现了部分式子（不足30个），是为了方便截图。式子的多少只需要更改for循环中的控制条件就行。

    2.当程序选择是分数运算时，用户只能分别输入分子与分母，不能同时输入。

    3.多元运算时，除法只能取整，这是一大弊端。

    时间记录日志：

    日期 开始 结束 中断时间 净时 事件 备注 c u
    2016.3.25 18.30 21.50 10 190 编码 商量    
    2016.3.26 9.00 16.20 60+20 360 编码 吃饭+商量    

    工作照：

    张更，陈昌
  • 相关阅读:
    harbor 报错，注意harbor.yml文件格式。
    nginx中rewrite文件
    改善github网络连接
    代码层实现六种质量属性战术
    读漫谈架构有感
    “淘宝网”的六个质量属性的六个常见属性
    寒假学习进度16：tensorflow2.0 波士顿房价预测
    寒假学习进度15：tensorflow2.0 优化器
    寒假学习进度14：对mnist数据集实现逻辑回归
    寒假学习进度13：tensorflow2.0 mnist简介
  • 原文地址：https://www.cnblogs.com/cchjl/p/5323275.html
Copyright © 2011-2022 走看看