• 小学自动生成四则运算二


          这是一个在自动生成计算式的代码上加强的新版本

          1.支持用户交互

          2.用户可以在线答题,程序会检查用户的答案是否正确

          3.增加了真分数的计算

          4.增加了有余数的计算

    思路:

          整数:

          1.需要生成式子,程序需要生成一定范围内的数,判断生成数的大小,在自动生成一个符号

          2.复杂的是除法,分母不能为0,并且生成的数可以整除

          分数:

          1.需要生成式子,程序需要生成一定范围内的数,判断生成数的大小,在自动生成一个符号

          2.分母不能为0

          3.加法与减法,需要求最小公倍数,结果必须最简化,求最大公约数,化简成最简。

    有余数的数:

          1.需要生成式子,程序需要生成一定范围内的数,判断生成数的大小,在自动生成一个符号

          2.计算结果比较简单,利用int型整除还能得到余数

    下面是源代码:

    import java.util.Random;
    import java.util.Scanner;
    
    class Suan1//生成整数计算的类
    {
        public int x,y,c;//定义两个变量,还有一个符号变量
        public Random random=new Random();//定义随机数
        String m;//生成的计算式储存咋m里面
        public String shengcheng()//自动生成数的函数
        {
            
             c=random.nextInt(4);//生成符号
             String fuhao;
             x=random.nextInt(100);//生成100以内的自然数
             y=random.nextInt(100);
             if(c==0)//0是加法
             {
                 fuhao="+";
             }
             else if(c==1)//1是减法
             {
                 fuhao="-";
             }
             else if(c==2)//2是乘法
             {
                 fuhao="*";
             }
             else
             {
                 fuhao="/";//3是除法
             }
             m=String.valueOf(x)+fuhao+String.valueOf(y);
             return m;
             
        }
        public int shuchu()//定义输出函数
        {
            if(c==0)
            {
                System.out.print(x+"+"+y+"=");
                return (x+y);//并且返回计算的结果
            }
            else if(c==1)
            {
                if(x>=y)//将较大的数放在前面,不能出现负数
                {
                System.out.print(x+"-"+y+"=");
                return (x-y);
                }
                else
                {
                    System.out.print(y+"-"+x+"=");
                return (y-x);
                }
            }
            else if(c==2)
            {
                if(x*y<100)//控制计算范围在100以内
                {
                    System.out.print(x+"*"+y+"=");
                    return (x*y);
                }
                else
                {
                    for(int i=0;;i++)
                    {
                        if(x*y<=100)//控制计算范围在100以内
                        {
                            System.out.print(x+"*"+y+"=");
                            return (x*y);
                        }
                        else
                        {
                            y=random.nextInt(100);
                        }
                    
                    }
                }
            }
            else
            {
                for(int i=0;;i++)
                {
                if(y==0)//分母不能为0
                {
                    y=random.nextInt();
                }
                else
                {
                    break;
                }
                }
                    System.out.print(x*y+"/"+y+"=");
                    return (x*y/y);
                    
            }
        }
        public int jianyan(String a[],int s)//检验是否有重复的式子,如果有返回0,没有就返回1
        {
           int flag=1;
           for(int i=0;i<s;i++)
           {
               if(m.equals(a[i]))//数组a里面是生成的式子
               {
                  flag=0;
                  break;
               }
           }
           return flag;
        }
    }
    class Suan2//真分数的运算类
    {
        public int m,n,x,y,c;//定义4个变量,还有一个符号变量
        public Random random=new Random();
        String s;//生成的计算式储存咋m里面
        public String shengcheng()
        {
            c=random.nextInt(4);
            x=random.nextInt(50);
            y=random.nextInt(50);
            m=random.nextInt(50);
            n=random.nextInt(50);//生成4个随机数在50以内,赋给x,y,m,n
            String fuhao;
            if(c==0)//通整数一样,0是加法,1减法,2乘法,3除法
             {
                 fuhao="+";
             }
             else if(c==1)
             {
                 fuhao="-";
             }
             else if(c==2)
             {
                 fuhao="*";
             }
             else
             {
                 fuhao="/";
             }
             s=String.valueOf(x)+fuhao+String.valueOf(y);//储存计算式
             return s;
        }
        public String shuchu()//定义输出函数
        {
            for(int i=0;;i++)
            {
                if(x==0)//不能生成0
                {
                x=random.nextInt(50);
                }
                else
                {
                    break;
                }
            }
            for(int i=0;;i++)
            {
                if(y==0)//不能生成0
                {
                y=random.nextInt(50);
                }
                else
                {
                    break;
                }
            }
            for(int i=0;;i++)
            {
                if(m==0)//不能生成0
                {
                m=random.nextInt(50);
                }
                else
                {
                    break;
                }
            }
            for(int i=0;;i++)
            {
                if(n==0)//不能生成0
                {
                n=random.nextInt(50);
                }
                else
                {
                    break;
                }
            }
            if(c==0)
            {
                if(x>y&&m>n)//生成的分母必须大于分子,输出不同的结果
                {
                System.out.print(y+"/"+x+"  +  "+n+"/"+m+"=");
                return jisuan(x,y,m,n,c);//返回计算结果
                }
                else if(x>y&&m<n)//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(y+"/"+x+"  +  "+m+"/"+n+"=");
                    return jisuan(x,y,n,m,c);//返回计算结果
                }
                else if(x<y&&m>n)//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(x+"/"+y+"  +  "+n+"/"+m+"=");
                    return jisuan(y,x,m,n,c);//返回计算结果
                }
                else//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(x+"/"+y+"  +  "+m+"/"+n+"=");
                    return jisuan(y,x,n,m,c);//返回计算结果
                }
            }
            else if(c==1)
            {
                double x1=Double.parseDouble(String.valueOf(x));
                double y1=Double.parseDouble(String.valueOf(y));
                double m1=Double.parseDouble(String.valueOf(m));
                double n1=Double.parseDouble(String.valueOf(n));    
                if(x>y&&m>n)//生成的分母必须大于分子,输出不同的结果
                {    
                    if((y1/x1)>(n1/m1))
                    {
                        System.out.print(y+"/"+x+"  -  "+n+"/"+m+"=");
                        return jisuan(x,y,m,n,c);//返回计算结果
                    }
                    else
                    {
                        System.out.print(n+"/"+m+"  -  "+y+"/"+x+"=");
                        return jisuan(m,n,x,y,c);//返回计算结果
                    }
                }
                else if(x>y&&m<n)//生成的分母必须大于分子,输出不同的结果
                {
                    if((y1/x1)>(m1/n1))//减数必须大于被减数
                    {
                        System.out.print(y+"/"+x+"  -  "+m+"/"+n+"=");
                        return jisuan(x,y,n,m,c);//返回计算结果
                    }
                    else//减数必须大于被减数
                    {
                        System.out.print(m+"/"+n+"  -  "+y+"/"+x+"=");
                        return jisuan(n,m,x,y,c);//返回计算结果
                    }
                }
                else if(x<y&&m>n)//生成的分母必须大于分子,输出不同的结果
                {
                    if((x1/y1)>(n1/m1))//减数必须大于被减数
                    {
                        System.out.print(x+"/"+y+"  -  "+n+"/"+m+"=");
                        return jisuan(y,x,m,n,c);
                    }
                    else//减数必须大于被减数
                    {
                        System.out.print(n+"/"+m+"  -  "+x+"/"+y+"=");
                        return jisuan(m,n,y,x,c);//返回计算结果
                    }
                }
                else
                {
                    if((x1/y1)>(m1/n1))//生成的分母必须大于分子,输出不同的结果//减数必须大于被减数
                    {
                        System.out.print(x+"/"+y+"  -  "+m+"/"+n+"=");
                        return jisuan(y,x,n,m,c);//返回计算结果
                    }
                    else//减数必须大于被减数
                    {
                        System.out.print(m+"/"+n+"  -  "+x+"/"+y+"=");
                        return jisuan(n,m,y,x,c);//返回计算结果
                    }
                }
            }
            else if(c==2)
            {
                if(x>y&&m>n)//生成的分母必须大于分子,输出不同的结果
                {
                System.out.print(y+"/"+x+"  *  "+n+"/"+m+"=");
                return jisuan(x,y,m,n,c);//返回计算结果
                }
                else if(x>y&&m<n)//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(y+"/"+x+"  *  "+m+"/"+n+"=");
                    return jisuan(x,y,n,m,c);//返回计算结果
                }
                else if(x<y&&m>n)//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(x+"/"+y+"  *  "+n+"/"+m+"=");
                    return jisuan(y,x,m,n,c);
                }
                else//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(x+"/"+y+"  *  "+m+"/"+n+"=");
                    return jisuan(y,x,n,m,c);//返回计算结果
                }
            }
            else
            {
                if(x>y&&m>n)//生成的分母必须大于分子,输出不同的结果
                {
                System.out.print(y+"/"+x+"  /  "+n+"/"+m+"=");
                return jisuan(x,y,m,n,c);//返回计算结果
                }
                else if(x>y&&m<n)//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(y+"/"+x+"  /  "+m+"/"+n+"=");
                    return jisuan(x,y,n,m,c);//返回计算结果
                }
                else if(x<y&&m>n)//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(x+"/"+y+"  /  "+n+"/"+m+"=");
                    return jisuan(y,x,m,n,c);//返回计算结果
                }
                else//生成的分母必须大于分子,输出不同的结果
                {
                    System.out.print(x+"/"+y+"  /  "+m+"/"+n+"=");
                    return jisuan(y,x,n,m,c);//返回计算结果
                }
            }
        }
        public String jisuan(int a,int b,int c,int d,int m)//计算结果的函数
        {
            String daan;
            int gongyue,gongbei;
            if(m==0)//加法计算的结果算法
            {
                gongbei=Gongbei(a,c);//求两个分母的最小公倍数
                int s1,s2,s3;
                s1=gongbei/a;
                s2=gongbei/c;
                s3=b*s1+d*s2;
                if(s3==gongbei)
                {
                    return("1");
                }
                else
                {
                    gongyue=Gongyue(s3,gongbei);
                    daan=String.valueOf(s3/gongyue)+"/"+String.valueOf(gongbei/gongyue);//通分
                    return daan;
                }
            }
            else if(m==1)//减法计算的结果算法
            {
                gongbei=Gongbei(a,c);
                int s1,s2,s3;
                s1=gongbei/a;
                s2=gongbei/c;
                s3=b*s1-d*s2;
                if(s3==gongbei)
                {
                    return("1");
                }
                else
                {
                    gongyue=Gongyue(s3,gongbei);
                    daan=String.valueOf(s3/gongyue)+"/"+String.valueOf(gongbei/gongyue);
                    return daan;
                }
            }
            else if(m==2)//乘法计算的结果算法
            {
                int s1,s2;
                s1=a*c;
                s2=b*d;
                if(s1==s2)
                {
                    return("1");
                }
                else
                {
                    gongyue=Gongyue(s1,s2);
                    daan=String.valueOf(s2/gongyue)+"/"+String.valueOf(s1/gongyue);
                    return daan;
                }
            }
            else//除法计算的结果算法
            {
                int s1,s2;
                s1=a*d;
                s2=b*c;
                if(s1==s2)
                {
                    return("1");
                }
                else
                {
                    gongyue=Gongyue(s1,s2);
                    daan=String.valueOf(s2/gongyue)+"/"+String.valueOf(s1/gongyue);
                    return daan;
                }
            }
        }
        public int Gongbei(int a,int c)//求最小公倍数的函数
        {
            int gongbei;
            if(a>c)
            {
                gongbei=a;//公倍数从大的开始
                while(gongbei<=a*c)
                {
                    if(gongbei%a==0&&gongbei%c==0)
                    {
                        break;
                    }
                    gongbei++;
                }
            }
            else
            {
                gongbei=c;//公倍数从大的开始
                while(gongbei<=a*c)
                {
                    if(gongbei%a==0&&gongbei%c==0)
                    {
                        break;
                    }
                    gongbei++;
                }
            }
            return gongbei;
            
        }
        public int Gongyue(int gongbei,int s3)//求最大公约数的函数
        {
            int i=1,gongyue=0;
            if(gongbei>s3)//公约数从1到最小的数
            {
                while(i<=s3)
                {
                    if(gongbei%i==0&&s3%i==0)
                    {
                        gongyue=i;
                    }
                    i++;
                }
                return gongyue;
            }
            else
            {
                while(i<=gongbei)
                {
                    if(gongbei%i==0&&s3%i==0)
                    {
                        gongyue=i;
                    }
                    i++;
                }
                return gongyue;
            }
        }
        public int jianyan(String a[],int l)//检验是否生成重复计算式的函数
        {
             int flag=1;
               for(int i=0;i<l;i++)
               {
                   if(s.equals(a[i]))
                   {
                      flag=0;
                      break;
                   }
               }
               return flag;
        }
    }
    class Suan3//有余数的类
    {
        public int x,y;//定义两个变量
        String m;
        public Random random=new Random();
        public String shengcheng()//定义生成函数
    
        {
            x=random.nextInt(100);
            y=random.nextInt(100);
            m=String.valueOf(x)+"/"+String.valueOf(y);//返回计算式
            return m;
        }
        public String shuchu()//生成输出函数
        {
            String daan;
            int shang,yushu;
            System.out.println(m+"=");
            shang=x/y;
            yushu=x-shang*y;
            daan=String.valueOf(shang)+"/"+String.valueOf(yushu);//返回计算结果
            return daan;
        }
        public int jianyan(String a[],int l)//检验是否重复的函数
        {
             int flag=1;
               for(int i=0;i<l;i++)
               {
                   if(m.equals(a[i]))
                   {
                      System.out.println(m);
                      flag=0;
                      break;
                   }
               }
               return flag;
        }
    }
    
    public class Jisuan {
    
        public static void main(String[] args) {
            // TODO 自动生成的方法存根
            Random random=new Random();
            Suan1 a=new Suan1();//定义整数运算变量a
            Suan2 b=new Suan2();//定义分数运算变量b
            Suan3 c=new Suan3();//定义余数运算变量c
            Scanner in=new Scanner(System.in);
            String shuju[]=new String[30];//定义储存计算式的数组
            int flag=0;//定义旗帜看是否有重复
            int m=0;
            for(int i=0;i<30;i++)
            {
                shuju[i]=new String();
            }
            for(int i=0;;i++)
            {
              System.out.println("1   整数的四则计算");
              System.out.println("2   真分数的四则计算");
              System.out.println("3   整数与真分数的混合四则运算");
              System.out.println("4   有余数的除法");//新添加的带括号的混合四则运算
              System.out.println("5   退出");
              System.out.print("请选择:");
              int t=in.nextInt();
              if(t==1)
              {
                while(m<30)//生成30个计算式
                 {
                        shuju[m]=a.shengcheng();//将生成的计算式储存咋数组里面
                        flag=a.jianyan(shuju, m);//返回是否有重复
                        if(flag==1)//如果没有就是1
                        {
                            int daan=a.shuchu();//输出式子,将答案储存在daan里面
                            String daan1=in.next();//用户输入答案
                            if(daan1.equals("break"))//用户不想做题时输入break跳出
                            {
                                break;
                            
                            }
                            else if(Integer.parseInt(daan1)==daan)//检查答案是否正确
                            {
                                System.out.println("回答正确!!!");
                            }
                            else
                            {
                            System.out.println("回答错误!!!正确答案是:"+daan);//如果不正确输出正确答案
                            }
                            m++;
                            flag=0;
                        }
                 }
                m=0;
              }
              else if(t==2)
              {
                  while(m<30)//生成30个计算式
                    {
                      shuju[m]=b.shengcheng();//将生成的计算式储存咋数组里面
                      flag=b.jianyan(shuju, m);//返回是否有重复
                        if(flag==1)//如果没有就是1
                        {
                            String daan=b.shuchu();//输出式子,将答案储存在daan里面
                            String daan1=in.next();//用户输入答案
                            if(daan1.equals("break"))//用户不想做题时输入break跳出
                            {
                                break;
                            
                            }
                            else if(daan1.equals(daan))//检查答案是否正确
                            {
                                System.out.println("回答正确!!!");
                            }
                            else
                            {
                            System.out.println("回答错误!!!正确答案是:"+daan);//如果不正确输出正确答案
                            }
                            m++;
                            flag=0;
                        }
                    }
                  m=0;
              }
              else if(t==3)//真是整数于分数混合的运算同上
              {
                  while(m<30)
                    {
                      int suiji=random.nextInt(2);
                      if(suiji==0)
                      {
                      shuju[m]=b.shengcheng();
                      flag=b.jianyan(shuju, m);
                      String daan=b.shuchu();
                        String daan1=in.next();
                        if(daan1.equals("break"))
                        {
                            break;
                        
                        }
                        else if(daan1.equals(daan))
                        {
                            System.out.println("回答正确!!!");
                        }
                        else
                        {
                        System.out.println("回答错误!!!正确答案是:"+daan);
                        }
                        m++;
                        flag=0;
                      }
                      else
                      {
                          shuju[m]=a.shengcheng();
                          flag=a.jianyan(shuju, m);
                          if(flag==1)
                            {
                                int daan=a.shuchu();
                                String daan1=in.next();
                                if(daan1.equals("break"))
                                {
                                    break;
                                
                                }
                                else if(Integer.parseInt(daan1)==daan)
                                {
                                    System.out.println("回答正确!!!");
                                }
                                else
                                {
                                System.out.println("回答错误!!!正确答案是:"+daan);
                                }
                                m++;
                                flag=0;
                            }
                      }
                    }
                  m=0;
              }
              
              else if(t==4)//余数的运算
              {
                  while(m<30)
                     {
                            shuju[m]=c.shengcheng();//将结果储存在数组里面
                            flag=c.jianyan(shuju, m);//检验是否有重复
                            if(flag==1)
                            {
                                String daan=c.shuchu();//输出式子,将答案储存在daan里面
                                System.out.print("商为:");
                                String shang=in.next();
                                System.out.print("余数为:");
                                String yushu=in.next();
                                if(daan.equals("break"))
                                {
                                    break;
                                
                                }
                                else if(daan.equals(shang+"/"+yushu))
                                {
                                    System.out.println("回答正确!!!");
                                }
                                else
                                {
                                 int weizhi=daan.indexOf('/');
                                 shang=daan.substring(0, 1);
                                 yushu=daan.substring(weizhi+1);
                                    
                                System.out.println("回答错误!!!正确答案是商"+shang+"余"+yushu);
                                }
                                m++;
                                flag=0;
                            }
                     }
                    m=0;
              }
              //有括号的四则运算
              else
              {
                  break;
              }
            }
            
    
        }
    
    }

    程序运行结果图:

                                                                                                    项目计划总结

        任务

    日期(min)

     听课

    阅读课 

      本

    编程

    准备考

      试

    日总计

       周日

      星期一

      160

      

     60

      130

      星期二

       20

     165

      185

      星期三

     120

      120

      星期四

     210

      240

      星期五

     60

      60

      星期六

      周总计

     

                                                                                                           时间记录日志

    开始时间

    结束时间

    中断时间

     净时间

      活动

      备注

    36

      18:40

     21:20

      20min

     140min

      听课,编程

    四则运算二

    37

      19:10  

     21:30

      10min

     130min

     编程

    四则运算二

    38

      19:00

     21:00

      10min

     110min

     阅读

    39

      19:20

     21:00

      10min

     90min

     编程

    四则运算二

    310

      16:00

     17:30

     90min

     编程

    四则运算的最后修改

     

     

                                                                                                          错误总计

    3月6日

    程序死循环,在循环中法跳出

    3月7日

    最大公倍数和最小公约数求得不对

    3月7日

    程序出现分母为0的情况,一直找不到哪里错误

  • 相关阅读:
    JSP基础学习(二)
    JSP基础学习(一)
    Android 使用开源xUtils来实现多线程下载(非原创)
    Android 多线程断点下载(非原创)
    Android HttpClient框架get和post方式提交数据(非原创)
    Android ListView使用(非原创)
    ScrollView 的使用(非原创)
    Android SQLite API的使用(非原创)
    Android SQLite的使用2(非原创)
    位运算
  • 原文地址:https://www.cnblogs.com/zll20153246/p/6532823.html
Copyright © 2020-2023  润新知