软件工程个人作业02

题目：

新增要求：

程序设计思想：

对于新添要求，可以新增一个类（OperationType类：用于控制参数，从而确定运算题目的类型），将新添的要求中需要控制的那些参数：有无括号、加减有无负数、除法有没有余数等等作为这个类的属性，然后通过用户的选择：例如要有括号、加减无负数、除法没有余数等作为值赋给类的一个对象来实例化一个类，然后将这个类的信息传递给进行四则运算的函数（有整数运算和真分数运算俩个函数）。

再对之前的程序中的进行四则运算的函数进行具体修改：

1：对于是否有乘法：可以通过在随机决定运算符的语句稍加修改，使得只产生加减俩种运算符。

2：对于是否有括号（诶暂时没想好）

3：对于数值范围：此处数值范围，我理解为题目中出现的一个数字的范围。可以在新增的OperationType类里定义startNumber（范围小值）和endNumber（范围大值）两个变量用于记录出题的数值范围。

4：对于加减有无负数：对随机出的题目先计算得出答案，若答案符合要求，则打印题目，如果答案不符合要求，则pass掉重新出题。

5：对于除法有无余数：除法有无余数这个参数只作用于整数运算（此处真分数运算我们不谈论取余），淘汰运算过程中出现余数的题目，重新出题。对结果进行取余即可。

源程序代码：

//信1505-1班20153319，李翠云，2017/3/9
//四则运算
/*要求：01
 1.支持真分数、整数的四则运算 √
 2.题目避免重复√     
 3.可定制数量 √
 追加要求（要求2）：（可控制如下参数）
 1。是否有乘除法
 2.是否有括号（最多可以支持十个数参与计算）
 3.数值范围
 4.加减有无负数
 5.除法有无余数
 */
package easyFourOperation02;
import java.util.Random;
import java.util.Scanner;  
/************************************为真分数运算而构造一个类，将分数的分子、分母作为类的数据成员。
 ********************************************/
class Calculator {  
    int numerator;  // 分子  
    int denominator; // 分母  
      
    Calculator(){  
    }  
  
    Calculator(int a,int b){  
        if(a == 0){  
            numerator = 0;  
            denominator = 1;  
        }  
        else{  
            setNumeratorAndDenominator(a,b);  
        }  
    }  
      
    void setNumeratorAndDenominator(int a, int b){  // 设置分子和分母  
        int c = f(Math.abs(a),Math.abs(b));         // 计算最大公约数  
        numerator = a / c;  
        denominator = b / c;  
        if(numerator<0 && denominator<0){  
            numerator = - numerator;  
            denominator = - denominator;  
        }  
    }  
      
    int getNumerator(){  
        return numerator;  
    }  
  
    int getDenominator(){  
        return denominator;  
    }  
      
    int f(int a,int b){  // 求a和b的最大公约数  
    
        if(a<b){int c=a;a=b;b=c;}
        int i;
        for(i=b;b>1;i--)
        {
            if(a%i==0&&b%i==0) return i;
        }
        return 1;
        
    }  
      
    Calculator add(Calculator r){  // 加法运算  
        int a = r.getNumerator();  
        int b = r.getDenominator();  
        int newNumerator = numerator * b + denominator * a;  
        int newDenominator = denominator * b;  
        Calculator result = new Calculator(newNumerator,newDenominator);  
        return result;  
    }  
      
    Calculator sub(Calculator r){  // 减法运算  
        int a = r.getNumerator();  
        int b = r.getDenominator();  
        int newNumerator = numerator * b - denominator * a;  
        int newDenominator = denominator * b;  
        Calculator result = new Calculator(newNumerator,newDenominator);  
        return result;  
    }   
      
    Calculator muti(Calculator r){ // 乘法运算  
        int a = r.getNumerator();  
        int b = r.getDenominator();  
        int newNumerator = numerator * a;  
        int newDenominator = denominator * b;  
        Calculator result = new Calculator(newNumerator,newDenominator);  
        return result;  
    }  
      
    Calculator div(Calculator r){  // 除法运算  
        int a = r.getNumerator();  
        int b = r.getDenominator();  
        int newNumerator = numerator * b;  
        int newDenominator = denominator * a;  
        Calculator result = new Calculator(newNumerator,newDenominator);  
        return result;  
    }  
      
 
}  
/************************************类结束******************************************************************************/

  






/****************************************OperationType类：用于控制参数***************************************/
class OperationType{
     boolean mul_Div;//1。是否有乘除法
     boolean parenthesis;//2.是否有括号（最多可以支持十个数参与计算）
     int startNumber,endNumber;//3.数值范围
     boolean negativeNumberOfAdd_Sub;//4.加减有无负数
     boolean remainderOfDiv;//5.除法有无余数
    public OperationType()
    {
        mul_Div=true;
        parenthesis=false;
        startNumber=1;
        endNumber=100;
        negativeNumberOfAdd_Sub=true;
        remainderOfDiv=false;
    }
    public OperationType(boolean mul_Div,boolean parenthesis,int startNumber,int endNumber,boolean negativeNumberOfAdd_Sub,boolean remainderOfDiv){
        this.mul_Div=mul_Div;
        this.parenthesis=parenthesis;
        this.startNumber=startNumber;
        this.endNumber=endNumber;
        this.negativeNumberOfAdd_Sub=negativeNumberOfAdd_Sub;
        this.remainderOfDiv=remainderOfDiv;
    }
}

  
/****************************************OperationType类结束：用于控制参数***************************************/ 





//public类FourOperation2
public class FourOperation2{
    static String str[];
    static Scanner sc=new Scanner(System.in);
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
        form();
        
    
    }
     
    public static void form()
    {
        
        int choice1,choice2,choice3,choice4;
        int total;
        OperationType OT=new OperationType();
        String str1="请选择（输入1或者2来进行选择）:"
                +"\n1:简单四则运算（无真分数）"
                +"\n2:真分数四则运算";
        System.out.println(str1);
        choice1=sc.nextInt();
        if(choice1!=1&&choice1!=2)
        {
            System.out.println("输入错误，请重新选择：");form();
        }
        System.out.println("\n\n");
        
        
        String str2="请选择（输入1或者2来进行选择）："
                +"\n1:按照不同年级出题"
                +"\n2:按照自己的喜欢需要来出题(例如：可以自己决定要不要乘除法、要不要带括号、要不要自己决定数值范围等等)";
        System.out.println(str2);
        choice2=sc.nextInt();
        if(choice2!=1&&choice2!=2)
        {
            System.out.println("输入错误，请重新选择：");form();
        }
        System.out.println("\n\n");
        
        
        //处理choice2
        if(choice2==1)//*************************************************待处理！！！！！！！！！！！！！！！！次要
        {
            String str3="请选择年级："
                    +"\n1：二年级"
                    +"\n2：三年级"
                    +"\n3：四年级"
                    +"\n4：五、六年级";
            System.out.println(str3);
            choice3=sc.nextInt();
            
        }
        
        
        else if(choice2==2)
        {
            System.out.println("是否需要乘除法（输入1或者2来进行选择）："+"\n1:需要"+"\n2:不需要");
            choice4=sc.nextInt();
            if(choice4==1) OT.mul_Div=true;
            else OT.mul_Div=false;
            System.out.println("是否需要括号（输入1或者2来进行选择）："+"\n1:需要"+"\n2:不需要");
            choice4=sc.nextInt();
            if(choice4==1) OT.parenthesis=true;
            else OT.parenthesis=false;
            System.out.println("是否需要控制数值范围（输入1或者2来进行选择）："+"\n1:需要"+"\n2:不需要");
            choice4=sc.nextInt();
            if(choice4==1) 
            {
                System.out.println("请输入最小数值(请输入一个整数)：");
                OT.startNumber=sc.nextInt();
                System.out.println("请输入最大数值(请输入一个整数)：");
                OT.endNumber=sc.nextInt();
                int t;
                if(OT.startNumber>OT.endNumber)//进行两数比较，避免用户输入顺序相反造成错误
                {
                    t=OT.startNumber;
                    OT.startNumber=OT.endNumber;
                    OT.endNumber=t;
                }
            }
            System.out.println("加减法运算结果是否允许出现负数（输入1或者2来进行选择）："+"\n1:允许"+"\n2:不允许");
            choice4=sc.nextInt();
            if(choice4==1) OT.negativeNumberOfAdd_Sub=true;
            else OT.negativeNumberOfAdd_Sub=false;
            System.out.println("除法运算是否取余数（输入1或者2来进行选择）："+"\n1:取余数"+"\n2:不取余数");
            choice4=sc.nextInt();
            if(choice4==1) OT.remainderOfDiv=true;
            else OT.remainderOfDiv=false;        
        }
        
                
        //控制出题数量
        System.out.println("请输入所需题量（请输入一个数）:");
        total=sc.nextInt();
        System.out.println("\n\n");
        
        //处理choice1*************************************待处理！！！！！！！！！！！！！1主要
        if(choice1==1)
            easyFourOperation(total,OT);
        else if(choice1==2)
            properFractionOperation(total,OT);
        
    }

    public static void easyFourOperation(int n,OperationType OT)//简单四则运算
    {
        str=new String[n];
        int ch;
        char char_='+';
        int i,j,k;
        int num;
        int answer=0;
        double answer_=0;//用于处理除法。避免结果取整而给出错误答案。
        boolean flag=false;
        int range;//用于控制是否有乘除法
        if(OT.mul_Div=true) range=4;
        else range=2;
        int length;//用于随机确定运算式操作数的个数。
        int[] brackets = null;//存储括号个数
        
        for(i=0;i<n;i++)
        {
            /*******生成运算式****/
            length=(int)(Math.random()*9+2);
            k=0;
            while(k<length)
            {
                num=(int)(Math.random()*(OT.endNumber-OT.startNumber)+OT.startNumber);
                ch=(int)(Math.random()*range+1);
                str[i]+=num;
                switch(ch)
                {
                case 1:char_='+';break;
                case 2:char_='-';break;
                case 3:char_='×';break;
                case 4:char_='÷';break;
                }
                if(k!=length-1) str[i]+=ch;
            
            }
            /********处理是否有括号：对上述运算式进行再加工********/
            if(OT.parenthesis) 
            {
                brackets=randomAddBracket(length);
                for(k=0;k<length;k++)
                {
                    if()
                }
                
            }
            
            //避免重复    
            for(j=0;j<i;j++)
                if(str[i].equals(str[j])) {flag=true;break;}
                    
            if(flag) {i--;flag=false;}
            else
            {
                System.out.println("题目"+(i+1)+":"+str[i]);
                System.out.println("是否查看答案？请选择：1：查看   2：不查看");
                int choice;
                choice=sc.nextInt();
                if(choice==1) System.out.println("答案："+answer+"\n");
            }
        }
    }
    
    public static void properFractionOperation(int n,OperationType O)//真分数运算
    {
        str=new String[n];
        int ch;
        char char_='+';
        int s,t,u,v;
        int i,j;
        int k,q;//用做两数交换的容器
        boolean flag=false;
        for(i=0;i<n;i++)
        {
            s=(int)(Math.random()*20);
            t=(int)(Math.random()*20);
            u=(int)(Math.random()*20);
            v=(int)(Math.random()*20);
            ch=(int)(Math.random()*4+1);
    
            if((s==0&&t==0)||(u==0&&v==0))
            {
                i--;continue;
            }
            if(s>t){k=s;s=t;t=k;}
            if(u>v){q=u;u=v;v=q;}
            
            Calculator C1=new Calculator(s,t);
            Calculator C2=new Calculator(u,v);
            Calculator answer=new Calculator();
            switch(ch)
            {
            case 1:char_='+';answer=C1.add(C2);break;
            case 2:char_='-';answer=C1.sub(C2);break;
            case 3:char_='×';answer=C1.muti(C2);break;
            case 4:char_='÷';if(u==0) {i--;continue;} answer=C1.div(C2);break;
            }
            
            str[i]=new String();
            str[i]=""+s+"/"+t+char_+u+"/"+v;
            
            //避免重复    
            for(j=0;j<i;j++)
                if(str[i].equals(str[j])) {flag=true;break;}
                    
            if(flag) {i--;flag=false;}
            else 
            {
                System.out.println("题目"+(i+1)+":"+str[i]);
                System.out.println("是否查看答案？请选择：1：查看   2：不查看");
                int choice;
                choice=sc.nextInt();
                if(choice==1) 
                {
                    if(answer.denominator==1) System.out.println("答案："+answer.numerator+"\n");
                    else System.out.println("答案："+answer.numerator+"/"+answer.denominator+"\n");
                }
            }
        }
        
    }
    
    
    //随机生成括号，参数为运算式的运算数的个数
        public static int[] randomAddBracket(int length){
            int[] brackets = new int[length];
            for(int i = 0;i < brackets.length;i++)   brackets[i] = 0;
            Random rd = new Random();
            for(int i = 2;i < length;i++){//添加的括号长度（括号包围的运算数的个数）
                for(int j = 0;j < length - i + 1;j++){
                    int t = rd.nextInt(2);//随机生成0或1，0代表不加括号，1代表加括号
                    if(t == 1){
                        if(brackets[j] >= 0 && brackets[j + i - 1] <= 0){//要加的括号的第一个运算数周围没有右括号，且 最后一个运算数周围没有左括号
                            int counteract = 0;
                            for(int k = j;k < j + i;k++){//将要加的括号之间的所有运算数对应的brackets相加，
                                                            //如果和为0说明这个括号之间的括号是匹配的，不会出现括号交叉现象
                                counteract += brackets[k];
                            }
                            if(counteract == 0){
                                brackets[j]++;
                                brackets[j + i - 1]--;
                            }
                        }
                    }
                }
            }
            return brackets;
        }

}

运行结果截图：

整数运算：

分数运算：

发表于 2017-03-09 22:31 耶路撒冷有多冷阅读(112) 评论(0) 收藏举报

公告