软件工程个人作业01

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

思路：（1）数据来源：整数 ---> 随机数生成

                            真分数---> 分子分母都随机产生，保证分子小于分母

                   四则符号随机---> 从0 ~ 3之间随机取数，取到0 代表“+”，取到1代表“-”，取到2代表“*”，取到3代表“ / ”。

        等式左边组合方式随机---> 从0 ~ 2之间取数，取到0代表两个整数做运算，取到1代表一个整数和一个真分数做运算，取到2代表两个真分数做运算。

       （2）真分数生成逻辑：随机生成两个整数，比较大小后，大的作为分母，小的作为分子，然后约分后返回字符串类型的值以作为打印显示，分子和分母的值存在一个定义好的对象中，方便其值够的传递

       （3）题目生成逻辑：在for循环下，先随机生成两个整数，两个真分数，一个运算符号，一个等式组合方式，然后通过if.. else..判断并打印在每个运算符号下，每一个等式组合方式生成的题目。

       （4）结果计算注意点：在减法运算中要注意结果不能为负数；在除法运算中要主以被除数不能为零；在真分数参与的运算中要注意分母不为0且但分母为1时就是分子的值，当分子的值为0时，该真分数的值就是0。

       （5）判断题目是否重复的逻辑：将之前用到记录真分数分子分母的类改造，增加两个私有String成员，定义一个类数组，用来记录每次随机产生的两个整数和每次生成的两个分数，然后在每次出题之前利用for循环将当前产生的一道题与之前生成的题比较（判断等式组合方式，运算符号，等式左边的两个数是否同时出现过），如果重复，i减减操作;并结束这次循环。

源代码：

package text;
import java.util.Scanner;

class Transmit {
    private int max;
    private int min;
    private String c1;
    private String c2;
    public String getC1() {
        return c1;
    }
    public void setC1(String c1) {
        this.c1 = c1;
    }
    public String getC2() {
        return c2;
    }
    public void setC2(String c2) {
        this.c2 = c2;
    }
    public int getMax() {
        return max;
    }
    public void setMax(int max) {
        this.max = max;
    }
    public int getMin() {
        return min;
    }
    public void setMin(int min) {
        this.min = min;
    }

}
public class Random {
    private static int line = 10;
    /**
     * 求两个数之间的最大公约数
     */
    public int getGCD(int max, int min) {
        int gcd = 1;
        if(min >= max) {
            int temp = max;
            max = min;
            min = temp;
        }
        for(int i = min;i>=1;i--) {
            if(max % i == 0 && min % i == 0) {
                gcd = i;
                break;
            }
        }
        return gcd;
    }

    /**
     * 生成真分数
     * @return 一个真分数的字符串
     */
    public String randZ( Transmit transmit) {        
         while(true){
             int max =(int)(Math.random()* line);
             int min =(int)(Math.random()* line);
             if(max==0 || min==0 || max == min) { //如果有一个为0,或者生成的两个数相等， continue;
                 continue;
             } else {
                 if(max <= min ) //先保证max的值大于min的值
                     {
                         int temp=min;
                         min=max;
                         max=temp;
                     }
                 //求最大公约数
                 int gcd = getGCD(max, min);
                 max = max / gcd;
                 min = min / gcd;
                     transmit.setMax(max);
                     transmit.setMin(min);
                     return("("+min+"/"+max+")");
                 }
             }
    }
    
    public String getMark(int midMax, int midMin) {
        int gcd = getGCD(midMax, midMin);//求最大公约数
        midMax = midMax / gcd;
        midMin = midMin / gcd;
        return(midMin+"/"+midMax);
    }
    //求两个真分数相加
    public String opGrsAdd(Transmit tran1,Transmit tran2) {
        int midMin = tran1.getMin() * tran2.getMax() + tran1.getMax() * tran2.getMin();
        int midMax = tran1.getMax() *  tran2.getMax();
        int gcd = getGCD(midMax, midMin);//求最大公约数
        midMax = midMax / gcd;
        midMin = midMin / gcd;
        if(midMax == midMin) {
            return 1+"";
        }else{
            return(midMin+"/"+midMax);
        }
    }
    
     //求两个真分数相乘
    public String opGrsMult(Transmit tran1, Transmit tran2) {
        int midMin = tran1.getMin() * tran2.getMin();
        int midMax = tran1.getMax()* tran2.getMax();
        return getMark(midMax, midMin);
    }
    
     //求两个真分数相减
    public String opGrsSubt(Transmit tran1, Transmit tran2) {
            int midMin = tran1.getMin() * tran2.getMax() - tran1.getMax() * tran2.getMin();
            int midMax = tran1.getMax() *  tran2.getMax();
            return getMark(midMax, midMin);
        }
        
     //求两个真分数相除
    public String opGrsDivi(Transmit tran1, Transmit tran2) { //tran1被除数，tran2除数
            int midMin = tran1.getMin() * tran2.getMax();
            int midMax = tran1.getMax()* tran2.getMin();
            int gcd = getGCD(midMax, midMin); //求最大公约数
            midMax = midMax / gcd;
            midMin = midMin / gcd;
            if(midMax == 1) {
                return midMin+"";
            }else {
            return(midMin+"/"+midMax);
            }
        }
    
    //求一个整数与一个真分数相加
    public String opGrsAddInt( int n , Transmit tran) {
        int midMin = n * tran.getMax() +tran.getMin();
        int midMax = tran.getMax() ;
        return getMark(midMax, midMin);
    }
    
    //求一个整数与一个真分数相减
    public String opGrsSubInt(int n, Transmit tran) {
        int midMin = n * tran.getMax() - tran.getMin();
        int midMax = tran.getMax() ;
        return getMark(midMax, midMin);
    }
    
    //求一个整数与一个真分数相乘
    public String opGrsMulInt(int n, Transmit tran) {
        int midMin  = n * tran.getMin();
        int midMax  = tran.getMax();
        int gcd = getGCD(midMax, midMin);//求最大公约数
        midMax = midMax / gcd;
        midMin = midMin / gcd;
        if(midMin == 0 ) {
            return 0+"";
        }else if (midMax == 1) {
            return midMin+"";
        }else{
            return(midMin+"/"+midMax);
        }
    }
    
    //求一个整数与一个真分数相除
    public String opGrsSDivInt(int n, Transmit tran) {
        int midMin  = n * tran.getMax();
        int midMax  = tran.getMin();
        int gcd = getGCD(midMax, midMin);//求最大公约数
        midMax = midMax / gcd;
        midMin = midMin / gcd;
        if(midMin == 0 ) {
            return 0+"";
        }else if (midMax == 1) {
            return midMin+"";
        }else{
            return(midMin+"/"+midMax);
        }
    }
    
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        Scanner stPut = new Scanner(System.in);
        Random ran = new Random();
        Transmit tran1= new Transmit();
        Transmit tran2= new Transmit();
        System.out.println("==========================");
        System.out.print("请输入出题数量：");
        int Num = input.nextInt();
        System.out.println("======本次出题数为："+Num+"道！"+"======");
        Transmit sameTran[] = new Transmit[Num+1];
        int sameZ[] = new int[Num +1];
        int sameSymbol[] = new int[Num +1];
        int trueNum = 0;
        int falseNum = 0;
        //for循环打印题目
         for(int i = 1; i<= Num ; i++) {
             int a =(int)(Math.random()* line); //随机生成两个整数
             int b =(int)(Math.random()* line); 
             String c1 = ran.randZ(tran1); //随机生成两个真分数
             String c2 = ran.randZ(tran2);
             //int symbol = 0;
             int  symbol = (int)(Math.random()*4); //生成  0~3 四个数代表四个运算符号
             int Z = (int) (Math.random()*3);   // 题目有三种情况，(1).两个整数间运算，(2).两个真分数间的运算，(3)真分数与整数间的运算
             sameTran[i] = new Transmit();
             sameTran[i].setMax(a);
             sameTran[i].setMin(b);
             sameTran[i].setC1(c1);
             sameTran[i].setC2(c2);
             sameSymbol[i] = symbol;
             sameZ[i] = Z;
             //判断是否重复
            for(int j = i; j <= 0; j++) {
                if(sameTran[i].getMax() == sameTran[j-1].getMax() && sameTran[i].getMin() ==sameTran[j-1].getMin()  
                        && sameSymbol[i] ==sameSymbol[j-1] && sameZ[i] == sameZ[j-1]) {
                    i--;continue;
                }else if(sameTran[i].getMax() ==sameTran[j-1].getMax() && sameTran[i].getC1() ==sameTran[j-1].getC1()   
                        && sameSymbol[i] ==sameSymbol[j-1] && sameZ[i] == sameZ[j-1]) {
                    i--;continue;
                }else if(sameTran[i].getC2() ==sameTran[j-1].getC2() && sameTran[i].getC1() ==sameTran[j-1].getC1()   
                        && sameSymbol[i] ==sameSymbol[j-1] && sameZ[i] == sameZ[j-1]) {
                    i--;continue;
                }
            } 
            
             if(symbol ==0) { //加法
                 System.out.print("第"+i+"题：");
                     if(Z == 1) {
                         System.out.print(a +" + " + b +" = " );
                         int result = input.nextInt();
                         if(result == (a+b)) {
                             trueNum++;
                             System.out.println("恭喜你，答对了！");
                         }else {
                             falseNum++;
                             System.out.println("真遗憾，答错了，正确答案是"+(a+b));
                         }
                 }else if( Z== 2) {
                      System.out.print(a +" + " + c1 +" = " );
                      String result = stPut.next();
                         if(result.equals(ran.opGrsAddInt(a, tran1))) {
                             trueNum++;
                             System.out.println("恭喜你，答对了！");
                         }else {
                             falseNum++;
                             System.out.println("真遗憾，答错了，正确答案是"+ran.opGrsAddInt(a, tran1));
                         }
                 }else if(Z == 0) {
                     System.out.print(c1 +" + " + c2 +" = " );
                     String result = stPut.next();
                         if(result.equals(ran.opGrsAdd(tran1, tran2))) {
                             trueNum++;
                             System.out.println("恭喜你，答对了！");
                         }else {
                             falseNum++;
                             System.out.println("真遗憾，答错了，正确答案是"+ran.opGrsAdd(tran1, tran2));
                         }
                 }
             }else if(symbol == 1 ){ //减法 
                 if(Z == 1) {
                     if((a-b) < 0 ) { 
                         i--; continue;
                     }else{ 
                          System.out.print("第"+i+"题：");
                          System.out.print(a +" - " + b +" = " );
                          int result = input.nextInt();
                          if(result == (a-b)) {
                                trueNum++;
                                 System.out.println("恭喜你，答对了！");
                             }else {
                                 falseNum++;
                                 System.out.println("真遗憾，答错了，正确答案是"+(a-b));
                             }
                     }
                 }else if( Z== 2) {
                     if(( a * tran1.getMax() - tran1.getMin() ) < 0) {
                         i--; continue;
                     }else {
                          System.out.print("第"+i+"题：");
                          System.out.print(a +" - " + c1 +" = " );
                          String result = stPut.next();
                          if(result.equals(ran.opGrsSubInt(a, tran1))) {
                                  trueNum++;
                                 System.out.println("恭喜你，答对了！");
                             }else {
                                 falseNum++;
                                 System.out.println("真遗憾，答错了，正确答案是"+ran.opGrsSubInt(a, tran1));
                             }
                     }
                 }else if(Z == 0) {
                     if(( tran1.getMin() * tran2.getMax() - tran1.getMax() * tran2.getMin() ) < 0 ) {
                        i--; continue;
                     }else{
                         System.out.print("第"+i+"题：");
                         if(c1.equals(c2)) {
                             System.out.print(c1 +" - " + c2 +" = ");
                              String result = stPut.next();
                                  if(result.equals("0")) {
                                          trueNum++;
                                         System.out.println("恭喜你，答对了！");
                                     }else {
                                         falseNum++;
                                         System.out.println("真遗憾，答错了，正确答案是"+"0");
                                     }
                         }else{
                            System.out.print(c1 +" - " + c2 +" = " );
                            String result = stPut.next();
                              if(result.equals(ran.opGrsSubt(tran1, tran2))) {
                                      trueNum++;
                                     System.out.println("恭喜你，答对了！");
                                 }else {
                                     falseNum++;
                                     System.out.println("真遗憾，答错了，正确答案是"+ran.opGrsSubt(tran1, tran2));
                                 }
                         }
                     }
                 }
             }else if(symbol == 2){ //乘法
                 System.out.print("第"+i+"题：");
                 if(Z == 1) {
                         System.out.print(a +" × " + b +" = " );
                         int result = input.nextInt();
                          if(result == (a*b)) {
                                trueNum++;
                                 System.out.println("恭喜你，答对了！");
                             }else {
                                 falseNum++;
                                 System.out.println("真遗憾，答错了，正确答案是"+(a*b));
                             }
                 }else if( Z== 2) {
                      System.out.print(a +" × " +c1 +" = " );
                      String result = stPut.next();
                      if(result.equals(ran.opGrsMulInt(a, tran1))) {
                                  trueNum++;
                                 System.out.println("恭喜你，答对了！");
                             }else {
                                 falseNum++;
                                 System.out.println("真遗憾，答错了，正确答案是"+ran.opGrsMulInt(a, tran1));
                             }
                 }else if(Z == 0) {
                     System.out.print(c1 +" × " + c2 +" = " );
                     String result = stPut.next();
                     if(result.equals(ran.opGrsMult(tran1, tran2))) {
                                 trueNum++;
                                 System.out.println("恭喜你，答对了！");
                             }else {
                                 falseNum++;
                                 System.out.println("真遗憾，答错了，正确答案是"+ran.opGrsMult(tran1, tran2));
                             }
                 }
             }else if(symbol == 3 ){ // 除法           
                 if(Z == 1 ) {
                         if(b == 0) {
                                i--; continue;
                         }else if (a == 0) {
                             System.out.print("第"+i+"题：");
                             System.out.print(a + " ÷ " + b +" = " );
                             String result = stPut.next();
                             if(result.equals("0")) {
                                         trueNum++;
                                         System.out.println("恭喜你，答对了！");
                                     }else {
                                         falseNum++;
                                         System.out.println("真遗憾，答错了，正确答案是"+"0");
                                     }
                         }else {
                                 System.out.print("第"+i+"题：");
                                 int gcd = ran.getGCD(b, a);
                                 int A = a / gcd; int B = b / gcd;
                                 if(B == 1) {
                                 System.out.print(a + " ÷ " + b +" = " );
                                 String result = stPut.next();
                                 if(result.equals(A)) {
                                             trueNum++;
                                             System.out.println("恭喜你，答对了！");
                                         }else {
                                             falseNum++;
                                             System.out.println("真遗憾，答错了，正确答案是"+A);
                                         }
                                 }else{
                                   System.out.print(a + " ÷ " + b +" = " );
                                  String result = stPut.next();
                                 if(result.equals(A+"/"+B)) {
                                             trueNum++;
                                             System.out.println("恭喜你，答对了！");
                                         }else {
                                             falseNum++;
                                             System.out.println("真遗憾，答错了，正确答案是"+(A+"/"+B));
                                         }
                                 }
                            }
                 }else if( Z== 2) {
                     System.out.print("第"+i+"题：");
                      System.out.print(a + " ÷ " + c1 +" = " );
                      String result = stPut.next();
                         if(result.equals(ran.opGrsSDivInt(a, tran1))) {
                                     trueNum++;
                                     System.out.println("恭喜你，答对了！");
                                 }else {
                                     falseNum++;
                                     System.out.println("真遗憾，答错了，正确答案是"+ran.opGrsSDivInt(a, tran1));
                                 }
                 }else if(Z == 0) {
                     System.out.print("第"+i+"题：");
                     System.out.print(c1 + " ÷ " + c2 +" = " );
                      String result = stPut.next();
                         if(result.equals(ran.opGrsDivi(tran1, tran2))) {
                                     trueNum++;
                                     System.out.println("恭喜你，答对了！");
                                 }else {
                                     falseNum++;
                                     System.out.println("真遗憾，答错了，正确答案是"+ran.opGrsDivi(tran1, tran2));
                                 }
                 }
             }
             if(i == 10){
                 System.out.println("==========================");
                 System.out.println("答题结束！本次共"+Num+"道题，你答对了"+trueNum+"道题，答错了"+falseNum+"道题！");
             }
         }     
    }
}

运行截图：