java-四则运算，自动出题（2）

 老师对自动出题的系统又有了新的功能：

1.是否有乘除法：

2.是否有括号：最多可支持十个数参与计算

3.数值范围：

4.加减结果有无负数：

5.除法结果有无余数：

（因为和上文的思路有些交汇，不懂的可以参考上文 》》点击这里参考上文）

 下面是我的思路：

1.是否有乘除法：

分条件设置a的值

如果选择无乘除：a=(int)(0+Math.random()*2);//a=0或a=1时分别对应着string数组的“+”“-”

如果选择无乘除：a=(int)(0+Math.random()*4)

2.是否有括号：最多可支持十个数参与计算

（有无括号涉及了多项式的加减乘除法，与原来的程序有很大的不同，需要重新改革，因为改革后还没有实现所有的要求的功能，所以我将在软件工程个人作业02 - 2中单独展示我的思路。）

3.数值范围：

通过设置数组内random的值来设置数值的范围：

//输入数值范围2017 3 8

System.out.println("功能3：输入数值范围：");

System.out.println("请输入上界：");

int number3=scan2.nextInt();

//说明：例如30-40是大于30不包括40的数

System.out.println("请输入下界：");

int number4=scan2.nextInt();

r1[i]=(int)(number3+Math.random()*(number4-number3));

r2[i]=(int)(number3+Math.random()*(number4-number3));

4.结果加减有无负数：

选择无负数：如果结果是负数，交换减数和被减数

int c;

    

c=r2[i];

r2[i]=r1[i];

r1[i]=c;

选择有负数：不用做任何操作。

5.结果除法有无余数：

选择结果无余数：随机生成除数，被除数限制成除数的k（k为整数）倍，因数值范围限制k的取值范围为1~（max-被除数）/被除数

结果有余数：则不用做任何操作。

下面是这次试验的代码：

package sum1;

import java.util.Scanner;

public class sum1 {
    //对于整数来书：建立两个int型的数组，储存信息，便于计算和判断
    //对于真分数来书，建立两个数组，比较数组的大小，大的赋值r1[i]
    static int[] r1;
    static int[] r2;
   //对于真分数来书，建立两个数组，比较数组的大小，大的赋值n3[i]
    static int[] n3;
    static int[] n4;
    //结果设置成double型的，因为整数相除容易出double
    static double[]S1;
    //计算真分数的计算结果，进行化简，储存信息
    static int[]S2;
    static int[]S3;
    
    static String[] r3={"+","-","*","/"};
    //将运算符储存在是s1[i]中，便于比较算式，生成不一样的数据
    static String s1[];
    //比较不同所需要用到的循环参数；
    static int j;
    /**
     * @param args
     */
    public static void main(String[] args) {
        
        while(true)
        {
            Scanner scan1=new Scanner(System.in);
            System.out.println("请输入选项：");
            System.out.println("1、整数计算  2、真分数计算 3、退出");
            
            int choose=scan1.nextInt();
            
            if(choose==1)
            {
                System.out.println("功能1：请输入定制数量：");
                Scanner scan2=new Scanner(System.in);
                int number=scan2.nextInt();
                
                //是否有乘除法 2017 3 6
                System.out.println("功能2：是否有乘除：0.否  1.是");
                int number2=scan2.nextInt();
                
                //输入数值范围2017 3 8
                System.out.println("功能3：输入数值范围：");
                System.out.println("请输入上界：");
                int number3=scan2.nextInt();
                //说明：例如30-40是大于30不包括40的数
                System.out.println("请输入下界：");
                int number4=scan2.nextInt();
                
                //加减有无负数 2017 3 8
                System.out.println("功能4：加减有无负数：0.否  1.是");
                int number5=scan2.nextInt();
                
                //除法有无余数 2017 3 8
                System.out.println("功能5：除法有无余数：0.否  1.是");
                int number6=scan2.nextInt();
                
                r1=new int[number];
                r2=new int[number];
                S1=new double[number];
                s1=new String[number];
                
                for(int i=0;i<number;i++)
                {
                    //是否有乘除法 2017 3 6（运算符操作）
                    int a=0;
                    if(number2==0)
                    {
                         a=(int)(0+Math.random()*2);
                    }
                    else
                    {
                        a=(int)(0+Math.random()*4);
                    }
                    
                    s1[i]=r3[a];
                    
                    //运算数操作制作2017 3 8
                    r1[i]=(int)(number3+Math.random()*(number4-number3));
                    
                    r2[i]=(int)(number3+Math.random()*(number4-number3));

                    
                    if(s1[i].equals("+"))
                    {
                        
                        S1[i]=(r1[i]+r2[i]);
                        
                        System.out.println(r1[i]+" + "+r2[i]+" =");
                    }
                    
                    else if(s1[i].equals("-"))
                    { 
                        if(number5==0)
                        {
                             if(r1[i]>r2[i])
                               {
                                   S1[i]=(r1[i]-r2[i]);
                                   System.out.println(r1[i]+" - "+r2[i]+" =");
                               }
                               //减号结果不为负数
                               else
                               {
                                    int c;
                                    
                                    c=r2[i];
                                    r2[i]=r1[i];
                                    r1[i]=c;
                                    
                                    S1[i]=(r1[i]-r2[i]);
                                    
                                   System.out.println(r1[i]+" - "+r2[i]+" =");
                               }
                        }
                        else
                        {
                            S1[i]=(r1[i]-r2[i]);
                            System.out.println(r1[i]+" - "+r2[i]+" =");
                        }
                      
                    }
                    
                    else if(s1[i].equals("*"))
                    {
                        S1[i]=(r1[i]*r2[i]);
                        System.out.println(r1[i]+" x "+r2[i]+" =");
                    }
                    else if(s1[i].equals("/"))
                    {
                        //无余数
                        if(number6==0)
                        { 
                            //如果所设范围太小，结果为整数的分母
                            r2[i]=(int)(number3+Math.random()*(number4-number3));
                            if(number4>number3)
                            r1[i]=r2[i]*(int)(1+Math.random()*(number4/r2[i]-1));
                            else
                            r1[i]=r2[i]*(int)(1+Math.random()*(number3/r2[i]-1));
                            
                            while(true)
                            {
                                if(r2[i]!=0)
                                {
                                     S1[i]=(r1[i]/r2[i]);
                                     System.out.println(r1[i]+" ÷ "+r2[i]+" =");
                                     break;
                                }
                                else //从新生成
                                {
                                    r2[i]=(int)(number3+Math.random()*(number4-number3));
                                    if(number4>number3)
                                    r1[i]=r2[i]*(int)(1+Math.random()*(number4/r2[i]-1));
                                    else
                                    r1[i]=r2[i]*(int)(1+Math.random()*(number3/r2[i]-1));
                                }
                            }    
                        }
                        
                        else
                        {
                            while(true)
                            {
                                if(r2[i]!=0)
                                {
                                     S1[i]=(r1[i]/r2[i]);
                                     System.out.println(r1[i]+" ÷ "+r2[i]+" =");
                                     break;
                                }
                                else //从新生成
                                {
                                    r2[i]=(int)(number3+Math.random()*(number4-number3));
                                }
                            }    
                            
                        }
                        
                    }
                    //for
                }
                
                System.out.println("是否输出定制结果？（1.输出    其他： 不输出）");
                Scanner scan3=new Scanner(System.in);
                int judge1=scan3.nextInt();
                
                if(judge1==1)
                {
                    for(int i=0;i<number;i++)
                    {
                        System.out.println("第"+(i+1)+"个算式的结果为："+S1[i]);
                    }
                }
                //choose
            }
            
            
             if(choose==2)
            {
                System.out.println("请输入定制数量：");
                Scanner scan2=new Scanner(System.in);
                int number=scan2.nextInt();
                
                //是否有乘除法 2017 3 6
                System.out.println("功能2：是否有乘除：0.否  1.是");
                int number2=scan2.nextInt();
                
                //输入数值范围2017 3 8
                System.out.println("功能3：输入数值范围：");
                System.out.println("请输入上界：");
                int number3=scan2.nextInt();
                //说明：例如30-40是大于30不包括40的数
                System.out.println("请输入下界：");
                int number4=scan2.nextInt();
                
                //加减有无负数 2017 3 8
                System.out.println("功能4：加减有无负数：0.否  1.是");
                int number5=scan2.nextInt();
                
                //除法有无余数 2017 3 8（分数的省略）
                
                r1=new int[number];
                r2=new int[number];
                n3=new int[number];
                n4=new int[number];
                
                S2=new int[number];
                S3=new int[number];
                
                for(int i=0;i<number;i++)
                {
                    r1[i]=(int)(number3+Math.random()*(number4-number3));
                    r2[i]=(int)(number3+Math.random()*(number4-number3));
                    
                    n3[i]=(int)(number3+Math.random()*(number4-number3));
                    n4[i]=(int)(number3+Math.random()*(number4-number3));
                    
                    //是否有乘除法 2017 3 6
                    int a=0;
                    if(number2==0)
                    {
                         a=(int)(0+Math.random()*2);
                    }
                    else
                    {
                        a=(int)(0+Math.random()*4);
                    }
                    
                    s1[i]=r3[a];
                    
                    for(j=0;j<i;j++)
                    {
                        if(r1[i]==r1[j]&&r1[i]==r1[j]&&s1[i].equals(s1[j])
                                &&n3[i]==n3[j]&&n4[i]==n4[j])
                        {
                            r1[i]=(int)(number3+Math.random()*(number4-number3));
                            r2[i]=(int)(number3+Math.random()*(number4-number3));
                            n3[i]=(int)(number3+Math.random()*(number4-number3));
                            n4[i]=(int)(number3+Math.random()*(number4-number3));
                            j=0;
                        }
                    }
                    while(r2[i]==0)
                    {
                        r2[i]=(int)(number3+Math.random()*(number4-number3));
                    }
                    
                    //返回最大公约数
                    int gy1=simple(r1[i],r2[i]);
                    
                    r1[i]=r1[i]/gy1;
                    r2[i]=r2[i]/gy1;
                    
                    //建立真分数
                    int c1;
                    
                    if(r1[i]>r2[i])
                    {
                        c1=r2[i];
                        r2[i]=r1[i];
                        r1[i]=c1;
                    }
                    
                    while(n4[i]==0)
                    {
                        n4[i]=(int)(number3+Math.random()*(number4-number3));
                    }
                    
                    //返回最大公约数
                    int gy2=simple(n3[i],n4[i]);
                    n3[i]=n3[i]/gy2;
                    n4[i]=n4[i]/gy2;
                    
                    //建立真分数
                    int c2;
                    
                    if(n3[i]>n4[i])
                    {
                        c2=n4[i];
                        n4[i]=n3[i];
                        n3[i]=c2;
                    }
                        
                    
                    if(s1[i].equals("+"))
                    {
                       S2[i]=r1[i]*n4[i]+r2[i]*n3[i];
                       S3[i]=r2[i]*n4[i];
                       //返回最大公约数
                        gy1=simple(S2[i],S3[i]);
                        
                        S2[i]=S2[i]/gy1;
                        S3[i]=S3[i]/gy1;
                       
                       System.out.println(r1[i]+"/"+r2[i]+" + "+n3[i]+"/"+n4[i]+" =");
                    }
                    
                    else if(s1[i].equals("-"))
                    {
                        if(number5==0)
                        {
                            S2[i]=r1[i]*n4[i]-r2[i]*n3[i];
                            
                            //结果为负数
                            if(S2[i]<0)
                            {
                                c2=n4[i];
                                n4[i]=r2[i];
                                r2[i]=c2;
                                
                                c2=r1[i];
                                r1[i]=n3[i];
                                n3[i]=c2;
                            }
                            
                            S2[i]=r1[i]*n4[i]-r2[i]*n3[i];
                            S3[i]=r2[i]*n4[i];
                               //返回最大公约数
                            gy1=simple(S2[i],S3[i]);
                                
                            S2[i]=S2[i]/gy1;
                            S3[i]=S3[i]/gy1;
                            
                           System.out.println(r1[i]+"/"+r2[i]+" - "+n3[i]+"/"+n4[i]+" =");
                            
                        }
                        else
                        {
                            S2[i]=r1[i]*n4[i]-r2[i]*n3[i];
                            S3[i]=r2[i]*n4[i];
                               //返回最大公约数
                            gy1=simple(S2[i],S3[i]);
                                
                            S2[i]=S2[i]/gy1;
                            S3[i]=S3[i]/gy1;
                            
                           System.out.println(r1[i]+"/"+r2[i]+" - "+n3[i]+"/"+n4[i]+" =");
                        }
                        
                    }
                    
                    else if(s1[i].equals("*"))
                    {
                        S2[i]=r1[i]*n3[i];
                        S3[i]=r2[i]*n4[i];
                           //返回最大公约数
                        gy1=simple(S2[i],S3[i]);
                            
                        S2[i]=S2[i]/gy1;
                        S3[i]=S3[i]/gy1;
                        
                       System.out.println(r1[i]+"/"+r2[i]+" x "+n3[i]+"/"+n4[i]+" =");
                    }
                    else if(s1[i].equals("/"))
                    {
                        S2[i]=r1[i]*n4[i];
                        S3[i]=r2[i]*n3[i];
                           //返回最大公约数
                        gy1=simple(S2[i],S3[i]);
                            
                        S2[i]=S2[i]/gy1;
                        S3[i]=S3[i]/gy1;
                        
                       System.out.println(r1[i]+"/"+r2[i]+" ÷  "+n3[i]+"/"+n4[i]+" =");
                    }
                    //for
                }
                
                System.out.print("是否输出定制结果？（1.输出    其他： 不输出）");
                Scanner scan4=new Scanner(System.in);
                int judge2=scan4.nextInt();
                
                if(judge2==1)
                {
                    for(int i=0;i<number;i++)
                    {
                        System.out.println("第"+(i+1)+"个算式的结果为："+S2[i]+"/"+S3[i]);
                    }
                }
                //choose
            }
            else if(choose==3)
            {
                break;
            }
            else 
            {
                System.out.println("输入有误，请重新输入！");
            }
            //while
        }
        //main
    }
    
    
    public static int simple(int n1,int n2)
    {
        int max = n2;
        
        if(n1>n2)
        {
            max=n1;
        }
        
        int gongyue=1;
        
        for(int i=1;i<=max;i++)
        {
            if(n1%i==0 && n2%i==0)
            {
                gongyue=i;
            }
        }
        return gongyue;
    }
}

下面是实验结果截图：

实验总结：

这次试验充分的体会到了在原来代码上进行功能的修改的方便性，大大缩短了实验的时间，当然，括号的功能让我了解了自己实现代码的不足，后来的修改让我感到了代码灵活性的重要性，这个实验的代码，让我限制在了两个数的加减乘除，修改的时候考虑到会花费很长时间进行修改，所以进行了翻改。