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;
          }
        }
        

    }

}