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

实验要求：

花二十分钟写一个能自动生成三十道小学四则运算题目的 “软件”，要求：除了整数以外，还要支持真分数的四则运算（需要验证结果的正确性）、题目避免重复、可定制出题的数量。

实验思路：

通过分析实验的要求理清自己的实验思路，循序渐进，我一共做了三段时间，自认为走了三步，一二步建立基础，第三步进行调试，整改，添加功能。

   第一大步（实现输入数量，产生随机的整数加减乘除算式）

 本人所用时间：大约20 minutes

1.先实现100以内的固定数量的随机加；

 r1[i]=(int)(1+Math.random()*100);

 r2[i]=(int)(1+Math.random()*100);

 r1[i]+r2[i];

2.然后实现随机的（“+”，“-”，“*”，“/”）

 建立储存运算符的char组 r3[]={“+”，“-”，“*”，“/”}

 static String[] r3={"+","-","*","/"};

 用随机的c=random（）,实现4以内的数字（0，1，2，3）, 就能随机产生运算符。

 int a=(int)(0+Math.random()*4);

 s1=r3[a];

4.实现可定义的数量，

 定义输入的int值m，建立相应的数组r1[number],r2[number];

System.out.print("请输入定制数量：");

Scanner scan2=new Scanner(System.in);

int number=scan2.nextInt();

r1=new int[number];

r2=new int[number];

综上，即可实现第一步。

   第二大步（产生随机的真分数加减乘除算式）

 本人所用时间：大约40minutes

1.建立4个随机整数组：

分别用来存储第一个分数的分子分母和第二个分数的分子分母；

 static int[] r1;

 static int[] r2;

 static int[] n3;

 static int[] n4;

2.用来进行运算的必须是最简分数，

需要定义一个求两个数的最大公约数的函数，再用这两个数除以最大公约数，留下来的才是最简分数。

//simple(int a,int b)求a,b的最大公约数。

int gy1=simple(r1[i],r2[i]);

r1[i]=r1[i]/gy1;

r2[i]=r2[i]/gy1;

3用来进行计算的还需是真分数

比较每个分数的分子分母，如果分子大于分母，就进行换位例如（5/3换成3/5）

if(r1[i]>r2[i])

{

c1=r2[i];

r2[i]=r1[i];

r1[i]=c1;

}

还需参考第一大步的内容，添加定义数量和随机运算符，可以轻松实现第二大步。

   第三大步（避免重复，并验证结果，以及其他功能）

 本人所用时间：大约60minutes

1.如何避免重复（以整数为例）

除了建立了两个随机数组储存信息外，我还建立了一个存储运算符的数组，当建立新的随机数式子时，与原随机数和匹配的运算符进行比较，若相同就再次随机产生，与原来的进行重复比对。（注意思考好循环结构，每新生成需要和原来所有的进行比较。）

for(int j=0;j<i;j++)

{

if(r1[i]==r1[j]&&r1[i]==r1[j]&&s1[i].equals(s1[j]))

{

            r1[i]=(int)(1+Math.random()*100);

r2[i]=(int)(1+Math.random()*100);

j=0;

}

}

2.如何验证算式的结果。

     这个比较简单，通过建立一个储存结果的数组，想要验证结果是否正确可以与相对应的结果数组内的数值进行比较。

3.得数不能为负数。

    主要是减法，当结果为负数时，减数和被减数调换位置。

4.分母不为0。

  当分母为0时重新生成分母即可。

 

随着用户要求的改变，第三大步可以进行相应的改变，总之，这个程序可变性很强的 （ ~/）

下面看一下程序的源代码：

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.print("请输入定制数量：");
                Scanner scan2=new Scanner(System.in);
                int number=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++)
                {
                    int a=(int)(0+Math.random()*4);
                    
                    s1[i]=r3[a];
                    
                    r1[i]=(int)(1+Math.random()*100);
                    
                    r2[i]=(int)(1+Math.random()*100);

                    
                    if(s1[i].equals("+"))
                    {
                        
                        S1[i]=(r1[i]+r2[i]);
                        
                        System.out.println(r1[i]+" + "+r2[i]+" =");
                    }
                    
                    else if(s1[i].equals("-"))
                    { 
                        
                       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 if(s1[i].equals("*"))
                    {
                        S1[i]=(r1[i]*r2[i]);
                        System.out.println(r1[i]+" x "+r2[i]+" =");
                    }
                    else if(s1[i].equals("/"))
                    {
                        S1[i]=(r1[i]/r2[i]);
                        while(true)
                        {
                            if(r2[i]!=0)
                            {
                                 System.out.println(r1[i]+" ÷ "+r2[i]+" =");
                                 break;
                            }
                            else 
                                r2[i]=(int)(1+Math.random()*100);
                        }    
                    }
                    //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.print("请输入定制数量：");
                Scanner scan2=new Scanner(System.in);
                int number=scan2.nextInt();
                
                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)(1+Math.random()*100);
                    r2[i]=(int)(1+Math.random()*100);
                    
                    n3[i]=(int)(1+Math.random()*100);
                    n4[i]=(int)(1+Math.random()*100);
                    
                    int 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)(1+Math.random()*100);
                            r2[i]=(int)(1+Math.random()*100);
                            n3[i]=(int)(1+Math.random()*100);
                            n4[i]=(int)(1+Math.random()*100);
                            j=0;
                        }
                    }
                    while(r2[i]==0)
                    {
                        r2[i]=(int)(1+Math.random()*100);
                    }
                    
                    //返回最大公约数
                    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)(1+Math.random()*100);
                    }
                    
                    //返回最大公约数
                    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("-"))
                    {
                        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 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;
    }
}

这是程序的结果截图：

         

        

最后总结一下未能快速完成的原因：

    不能很快的清理自己的思路，需要边写边打代码，一步步进行调试，无法做到一步到位，其实我觉得这很正常，本来我就知道一口吃不下一个胖子，我的技能还需要进行培养，思路还需要进行强化。