软件工程个人作业03

设计思想:在‘四则运算二’的基础上加上新的功能。首先,对上一个的源代码,进行一次优化。然后加上我新的功能。

1)计算题目答案功能,把实现的语句加入到判断的方法体中。我会代表分子的一个数组和一个分母的数组,加上一个运算符的数组,记录题目计算的中间

过程。根据四则运算的规则,先算乘除,后算加减。所以第一次遍历运算符数组,计算乘除法的计算,把两个数的结果记录到后一个的分子和分母上,同时前一个数的分子赋值为0,两数中间的运算符修改为+号。第二次遍历计算加减,依次从左到又依次计算。最后的答案为运算数数组中最后一个数,一个分母,一个分子,在进行化简。

2)打印对齐。我会根据运算式的种类(2个数或者多项式),定义两个长度,如果运算式的长度小于定义长度,则输出空格,直至与定义长度相同

3)除法与分数区别开,分数用括号区分开来。

4)最后会对题目是否有乘除法、题目是否有括号、取值范围、加减有无负数、除法有无余数、题目中是否包含分数这六个参数进行整合。

源程序代码:

//范亚雷    2016年03月21号
//二柱子问题第三次编写


import javax.swing.JOptionPane;
import java.util.Arrays;

class DateANDShow{
    int[] Parameter=new int[6];       //分别对应6个参数的一个长度为6的数组
    int[] z=new int[11];int z1;       //随机产生加减乘除的四则运算(0+;1-;2*;3/)
    int[] Num1=new int[10];           //代表可能的多项式运算的运算数或分子
    int[] Num2=new int[10];           //代表可能的多项式运算的分母
    int Magnification=0;                //数值范围
    int OperationNum=2;                 //有括号情况确定运算个数
    int[] Brace_position=new int[6];  //3个括号位置
    String answer=new String();
    String output=new String();
    DateANDShow(){}
    DateANDShow(int a1,int a2,int a3,int a4,int a5,int a6){     //传进可控参数,并确定一些必要数据
        output="";
        Parameter[0]=a1;     //代表是否有乘除法
        
        if(Parameter[0]==0)  //确定题目中有无乘除
            z1=4;            
        if(Parameter[0]==1)
            z1=2;
        
        Parameter[1]=a2;     //代表是否有括号
        
        //确定计算个数
        if(Parameter[1]==0)
            OperationNum=(int)(Math.random()*9+2);
        if(Parameter[1]==1)
            OperationNum=2;
        System.out.println("OperationNum"+OperationNum);
        
        Parameter[2]=a3;     //代表取值范围
        
        //确定取值范围
        if(Parameter[2]==0)
            Magnification=100;
        if(Parameter[2]==1)
            Magnification=200;
        if(Parameter[2]==2)
            Magnification=300;
        if(Parameter[2]==3)
            Magnification=500;
        if(Parameter[2]==4)
            Magnification=1000;
        if(Parameter[2]==5)
            Magnification=5000;
        if(Parameter[2]==6)
            Magnification=10000;
        Parameter[3]=a4;     //代表加减有无负数
        Parameter[4]=a5;     //代表除法有无余数
        Parameter[5]=a6;     //代表题目中是否有分数
    }
     
    public void Generate_random_number(){     //产生随机的数据
        
        //初始化分母
        for(int i=0;i<10;i++)
        {
            Num2[i]=1;
        }
        //产生运算数
        for(int i=0;i<OperationNum;i++)
        {
            Num1[i]=(int)(Math.random()*Magnification);
            
            //随机确定是否为负数,1/14的几率
            int t=(int)(Math.random()*15);
            if(t==10)
                Num1[i]=-Num1[i];
            
            //随机确定是否为分数运算,1/29的几率
            if(Parameter[5]==0)
            {
                 int T=(int)(Math.random()*30);
                 if(T==10)
                    {Num2[i]=(int)(Math.random()*Magnification);}
                 while(Num2[i]==0)
                 {Num2[i]=(int)(Math.random()*Magnification);}
            }
            System.out.println("Num"+Num1[i]);
        
        }
        for(int i=1;i<11;i++)//初始化运算符为非法值
        {
            z[i]=4;
        }
        //产生随机运算符
        for(int i=1;i<OperationNum;i++)
        {
            z[i]=(int)(Math.random()*z1);
            System.out.println("zifu"+z[i]);
        }
        
        //随机确定括号的位置
        if(Parameter[1]==0&&OperationNum>2)
        {
            //初始化括号的位置数组
            for(int j=0;j<6;j++)
                {Brace_position[j]=OperationNum;}
            int i=0;
            if(OperationNum>2&&OperationNum<=5)   //3-5个数运算,随机产生1个括号
                {i=3;}
            if(OperationNum>5&&OperationNum<=7)   //6、7个数运算,随机产生2个括号
                {i=2;}
            if(OperationNum>7&&OperationNum<=10)   //7-10个数运算,随机产生3个括号
                {i=1;}
            switch(i)
            {
             case 0:break;
             case 1:int t1=(int)(Math.random()*10);
                    if(t1==1)
                    {
                        Brace_position[5]=(int)(Math.random()*OperationNum);  //0、1、2、3、4、5。。。OperationNum
                        Brace_position[4]=(int)(Math.random()*OperationNum);
                        
                        while(Brace_position[5]==Brace_position[4]) //排除括号位置相同的情况
                            {Brace_position[4]=(int)(Math.random()*OperationNum);}
                    }
             case 2:int t2=(int)(Math.random()*10);
                    if(t2==1)
                    {
                        Brace_position[3]=(int)(Math.random()*OperationNum);  //0、1、2、3。。。OperationNum
                        while((Brace_position[3]==Brace_position[5])||(Brace_position[3]==Brace_position[4])) //排除括号位置相同的情况
                           {Brace_position[3]=(int)(Math.random()*OperationNum);}
                        Brace_position[2]=(int)(Math.random()*OperationNum);  
                        while((Brace_position[2]==Brace_position[5])||(Brace_position[2]==Brace_position[4])||(Brace_position[2]==Brace_position[3])) //排除括号位置相同的情况
                           {Brace_position[2]=(int)(Math.random()*OperationNum);}
                    }
             case 3:int t3=(int)(Math.random()*10);
                    if(t3==1)
                    {
                        Brace_position[1]=(int)(Math.random()*OperationNum);  //0、1、2、3。。。OperationNum
                        while((Brace_position[1]==Brace_position[5])||(Brace_position[1]==Brace_position[4])||(Brace_position[1]==Brace_position[3])||(Brace_position[1]==Brace_position[2])) //排除括号位置相同的情况
                           {Brace_position[1]=(int)(Math.random()*OperationNum);}
                        Brace_position[0]=(int)(Math.random()*OperationNum);
                        while((Brace_position[0]==Brace_position[5])||(Brace_position[0]==Brace_position[4])||(Brace_position[0]==Brace_position[3])||(Brace_position[0]==Brace_position[2])||(Brace_position[0]==Brace_position[1])) //排除括号位置相同的情况
                           {Brace_position[0]=(int)(Math.random()*OperationNum);}
                    }
                    break;
            }
        }
    }
    public void The_Fraction_In(int a,int b){ //化简分数
        int gcd=1;
        for(int k=2;k<=a&&k<=b;k++)
            {
                if(a%k==0&&b%k==0)
                {gcd=k;}
            }
        a=a/gcd;b=b/gcd;
        System.out.println("答案:"+a+"/"+b);
        if(b==1||a==0)
            {answer=""+a;}
        else
            {answer=""+a+"/"+b;}
    }
    public void Judge1(){     //判断是否符合参数(只有两个数运算且没有分数)
        if(z[1]==0)    //排除加法结果中是负数的情况
        {
            while(((Num1[0]+Num1[1])<0)&&(Parameter[3]==1))
                {
                   Num1[0]=(int)(Math.random()*Magnification);
                   Num1[1]=(int)(Math.random()*Magnification);
                }
            output=output+Num1[0];
            output=output+"+";
            int sum=Num1[0]+Num1[1];
            answer=""+sum;
        }
        if(z[1]==1)    //排除减法结果中是负数的情况
        {
            if(Num1[1]>Num1[0]&&Parameter[3]==1)
                {
                int t=Num1[1];
                Num1[1]=Num1[0];
                Num1[0]=t;
                }
            output=output+Num1[0];
            output=output+"-";
            int sum=Num1[0]-Num1[1];
            answer=""+sum;
        }    
       
        if(z[1]==2)
        {
            output=output+Num1[0];
            output=output+"*";
            int sum=Num1[0]*Num1[1];
            answer=""+sum;
           }
           if(z[1]==3)     //排除除法为0和有余数的情况
        {
               while(Num1[1]==0)
                {Num1[1]=(int)(Math.random()*Magnification);}
           
               if(Parameter[4]==1)
               {
                   while((Num1[0]%Num1[1]!=0)||(Num1[1]==0))
                   {
                       Num1[1]=(int)(Math.random()*Magnification+1);
                       Num1[0]=(int)(Math.random()*Magnification);
                   }
               }        
            output=output+Num1[0];
            output=output+"/"; 
            if((Num1[0]%Num1[1]!=0))
             {int sum=Num1[0]/Num1[1];
              answer=""+sum;}
            else
            {answer=""+Num1[0]+"/"+Num1[1];}
            }
 
           output=output+Num1[1]+"=";
           //System.out.println(output+"output");
    }
    public void Judge11(){    //判断是否符合参数(只有两个数运算但第一个为分数)
        if(z[1]==0)    //排除加法结果中是负数的情况
        {
            while(((Num1[0]/Num2[0]+Num1[1])<0)&&(Parameter[3]==1))
                {
                   Num1[1]=(int)(Math.random()*Magnification);
                }
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"+";
            
            int fenzi=Num1[0]+Num2[0]*Num1[1];
            int fenmu=Num2[0];
            answer=""+fenzi+"/"+fenmu;
        }
        if(z[1]==1)    //排除减法结果中是负数的情况
        {
            while(Num1[1]>(Num1[0]/Num2[0])&&Parameter[3]==1)
                {
                Num1[1]=(int)(Math.random()*Magnification);
                }
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"-";
            
            int fenzi=Num1[0]-Num2[0]*Num1[1];
            int fenmu=Num2[0];
            answer=""+fenzi+"/"+fenmu;
        }    
       
        if(z[1]==2)
        {
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"*";
            
            int fenzi=Num1[0]*Num1[1];
            int fenmu=Num2[0];
            answer=""+fenzi+"/"+fenmu;
           }
           if(z[1]==3)     //排除除法为0的情况
        {
               while(Num1[1]==0)
                {Num1[1]=(int)(Math.random()*Magnification);}
           
            output=output+Num1[0];
            output=output+"/"; 
            
            int fenzi=Num1[0];
            int fenmu=Num2[0]*Num1[1];
            The_Fraction_In(fenzi,fenmu);
 
           output=output+Num1[1]+"=";
        }
    }
    public void Judge12(){    //判断是否符合参数(只有两个数运算但第二个为分数)
        if(z[1]==0)    //排除加法结果中是负数的情况
        {
            while(((Num1[0]+Num1[1]/Num2[1])<0)&&(Parameter[3]==1))
                {
                   Num1[0]=(int)(Math.random()*Magnification);
                }
            output=output+Num1[0];
            output=output+"+";
            
            int fenzi=Num1[1]+Num2[1]*Num1[0];
            int fenmu=Num2[0];
            The_Fraction_In(fenzi,fenmu);
        }
        if(z[1]==1)    //排除减法结果中是负数的情况
        {
            while(Num1[0]<(Num1[1]/Num2[1])&&Parameter[3]==1)
                {
                Num1[0]=(int)(Math.random()*Magnification);
                }
            output=output+Num1[0];
            output=output+"-";
            
            int fenzi=Num2[1]*Num1[0]-Num1[1];
            int fenmu=Num2[1];
            The_Fraction_In(fenzi,fenmu);
        }    
       
        if(z[1]==2)
        {
            output=output+Num1[0];
            output=output+"*";
            
            int fenzi=Num1[0]*Num1[1];
            int fenmu=Num2[1];
            The_Fraction_In(fenzi,fenmu);
           }
           if(z[1]==3)     //排除除法为0的情况
        {
               while(Num1[1]==0)
                {Num1[1]=(int)(Math.random()*Magnification);}
           
            output=output+Num1[0];
            output=output+"/"; 
            
            int fenzi=Num2[1]*Num1[0];
            int fenmu=Num1[1];
            The_Fraction_In(fenzi,fenmu);
 
           output=output+"("+Num1[1]+"/"+Num2[1]+")"+"=";
        }
           
    }
    public void Judge13(){    //判断是否符合参数(只有两个数运算但均为为分数)
        if(z[1]==0)    //排除加法结果中是负数的情况
        {
            while(((Num1[0]/Num2[0]+Num1[1]/Num2[1])<0)&&(Parameter[3]==1))
                {
                   Num1[0]=(int)(Math.random()*Magnification);
                   Num1[1]=(int)(Math.random()*Magnification);
                }
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"+";
            
            int fenzi=Num1[0]*Num2[1]+Num1[1]*Num2[0];
            int fenmu=Num2[0]*Num2[1];
            answer=""+fenzi+"/"+fenmu;
        }
        if(z[1]==1)    //排除减法结果中是负数的情况
        {
            while(Num1[0]<(Num1[1]/Num2[1])&&Parameter[3]==1)
                {
                Num1[0]=(int)(Math.random()*Magnification);
                }
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"-";
            
            int fenzi=Num1[0]*Num2[1]-Num1[1]*Num2[0];
            int fenmu=Num2[0]*Num2[1];
            answer=""+fenzi+"/"+fenmu;
        }    
       
        if(z[1]==2)
        {
            output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"*";
            
            int fenzi=Num1[0]*Num1[1];
            int fenmu=Num2[1]*Num2[0];
            answer=""+fenzi+"/"+fenmu;
           }
           if(z[1]==3)     //排除除法为0的情况
        {
               while(Num1[1]==0)
                {Num1[1]=(int)(Math.random()*Magnification);}
           
               output=output+"("+Num1[0]+"/"+Num2[0]+")";
            output=output+"/"; 
            
            int fenzi=Num1[0]*Num2[1];
            int fenmu=Num2[0]*Num1[1];
            answer=""+fenzi+"/"+fenmu;
 
           output=output+"("+Num1[1]+"/"+Num2[1]+")"+"=";
        }
    }
    public void Judge2(){     //判断是否符合参数(只有两个数运算但有分数参与)
        if(Num2[0]==1&&Num2[1]==1)  //包含分数,但随机确定的均未产生分数
        {
            Judge1();
        }
        else if(Num2[0]!=1&&Num2[1]==1)
        {
            Judge11();
        }
        else if(Num2[0]==1&&Num2[1]!=1)
        {
            Judge12();
        }
        else
        {
            Judge13();
        }
    }
    public void Arithmetic(){              //进行四则运算(没有括号)
        int[] Operator=new int[10];    //运算符
        int[] Num3=new int[10];        //运算数
        int[] Num4=new int[10];        //运算结果的分母
        //The_Fraction_In(a,b);
        for(int i=0;i<OperationNum;i++)      //初始化为0
            {
                Num3[i]=Num1[i];  //运算数写入Num2数组中
                if(Parameter[5]==1)
                 {Num4[i]=1;}
                if(Parameter[5]==0)
                 {Num4[i]=Num2[i];}
                if(i!=0)
                  {Operator[i]=z[i];}  //运算符 写入sum数组中
            }
        //先计算乘除
        for(int i=1;i<OperationNum;i++)
        {
            if(Operator[i]==2)
            {
                Num3[i]=Num3[i-1]*Num3[i];   //分子
                Num4[i]=Num4[i-1]*Num4[i];   //分母
                Num3[i-1]=0;
                Operator[i]=0;
            }
            if(Operator[i]==3)
            {
                while(Num3[i]==0)
                       {Num3[i]=(int)(Math.random()*Magnification);}
                    
                Num3[i]=Num4[i-1]*Num3[i];
                Num4[i]=Num4[i]*Num3[i-1];
                Num3[i-1]=0;
                Operator[i]=0;
                //交换分子和分母
                int t;
                t=Num3[i];
                Num3[i]=Num4[i];
                Num4[i]=t;
            }
        }
        //后计算加减
        for(int i=1;i<OperationNum;i++)
        {
            if(Operator[i]==0)
            {
                    Num3[i]=Num4[i-1]*Num3[i]+Num4[i]*Num3[i-1];   //分子
                    Num4[i]=Num4[i-1]*Num4[i];   //分母
                    Num3[i-1]=0;
                    Operator[i]=0;
            }
            if(Operator[i]==1)
            {
                Num3[i]=Num4[i]*Num3[i-1]-Num4[i-1]*Num3[i];   //分子
                Num4[i]=Num4[i-1]*Num4[i];   //分母
                Num3[i-1]=0;
                Operator[i]=0;
            }
        }
        for(int i=0;i<OperationNum;i++)
        {
            if(Num2[i]!=1)
            {output=output+"(";}
            
            output=output+Num1[i];
            
            if(Num2[i]!=1)
            {output=output+"/"+Num2[i]+")";}
            
            if(z[i+1]==0)
                {output=output+"+";}
            if(z[i+1]==1)
                {output=output+"-";}
            if(z[i+1]==2)
                {output=output+"*";}
            if(z[i+1]==3)
                {output=output+"/";}
        }
        output=output+"=";
        System.out.println("output"+output);
        The_Fraction_In(Num3[OperationNum-1],Num4[OperationNum-1]);
        
    }
    public void Braces_polynomial(){  //进行四则运算(有括号)
        int[] Operator=new int[10];      //运算符
        int[] Num3=new int[10];          //运算数
        int[] Num4=new int[10];          //运算结果的分母
        int[] Brace_position1=new int[6]; //括号位置
        int j=0;                           //代表括号的数量
        int Left=0;int Right=0;
        for(int i=0;i<OperationNum;i++)      //初始化为0
            {
                Num3[i]=Num1[i];  //运算数写入Num2数组中
                if(Parameter[5]==1)
                 {Num4[i]=1;}
                if(Parameter[5]==0)
                 {Num4[i]=Num2[i];}
                if(i!=0)
                  {Operator[i]=z[i];}  //运算符 写入sum数组中
            }
         for(int i=0;i<6;i++)
            {
                if(Brace_position[i]!=OperationNum)
                    {j++;}
                Brace_position1[i]=Brace_position[i];
                System.out.println("kuohao"+i+":  "+Brace_position[i]);
                System.out.println("kuohao"+Brace_position1[i]);
            }
        Arrays.sort(Brace_position1);  //括号位置排序
        System.out.println(j);
        int x=j;
         //先计算括号里面的情况
        for(int a=0;a<x/2;a++)
        {
            Left=Brace_position1[j/2-1];  //左括号位置
            System.out.println("left"+Left);
            Right=Brace_position1[j/2];   //右括号位置
            System.out.println("right"+Right);
            
            for(int i=Left+1;i<Right+1;i++)
            {
                if(Operator[i]==2)
                {
                    Num3[i]=Num3[i-1]*Num3[i];   //分子
                    Num4[i]=Num4[i-1]*Num4[i];   //分母
                    Num3[i-1]=0;
                    Num4[i-1]=1;
                    Operator[i]=0;
                }
                if(Operator[i]==3)
                {
                    while(Num3[i]==0)
                           {Num3[i]=(int)(Math.random()*Magnification);}
                        
                    Num3[i]=Num4[i-1]*Num3[i];
                    Num4[i]=Num4[i]*Num3[i-1];
                    Num3[i-1]=0;
                    Num4[i-1]=1;
                    Operator[i]=0;
                    //交换分子和分母
                    int t;
                    t=Num3[i];
                    Num3[i]=Num4[i];
                    Num4[i]=t;
                }
            }
            //后计算加减
            for(int i=Left+1;i<Right+1;i++)
            {
                if(Operator[i]==0)
                {
                        Num3[i]=Num4[i-1]*Num3[i]+Num4[i]*Num3[i-1];   //分子
                        Num4[i]=Num4[i-1]*Num4[i];   //分母
                        Num3[i-1]=0;
                        Num4[i-1]=1;
                        Operator[i]=0;
                }
                if(Operator[i]==1)
                {
                    Num3[i]=Num4[i]*Num3[i-1]-Num4[i-1]*Num3[i];   //分子
                    Num4[i]=Num4[i-1]*Num4[i];   //分母
                    Num3[i-1]=0;
                    Num4[i-1]=1;
                    Operator[i]=0;
                }
            }
            Brace_position1[j/2-1]=OperationNum;
            Brace_position1[j/2]=OperationNum;
            Arrays.sort(Brace_position1);  //括号位置排序
            j=j-2;
        }
         
         //后计算括号外面
         //先计算乘除
        for(int i=1;i<OperationNum;i++)
        {
            if(Operator[i]==2)
            {
                Num3[i]=Num3[i-1]*Num3[i];   //分子
                Num4[i]=Num4[i-1]*Num4[i];   //分母
                Num3[i-1]=0;
                Operator[i]=0;
            }
            if(Operator[i]==3)
            {
                while(Num3[i]==0)
                       {Num3[i]=(int)(Math.random()*Magnification);}
                    
                Num3[i]=Num4[i-1]*Num3[i];
                Num4[i]=Num4[i]*Num3[i-1];
                Num3[i-1]=0;
                Operator[i]=0;
                //交换分子和分母
                int t;
                t=Num3[i];
                Num3[i]=Num4[i];
                Num4[i]=t;
            }
        }
        //后计算加减
        for(int i=1;i<OperationNum;i++)
        {
            if(Operator[i]==0)
            {
                    Num3[i]=Num4[i-1]*Num3[i]+Num4[i]*Num3[i-1];   //分子
                    Num4[i]=Num4[i-1]*Num4[i];   //分母
                    Num3[i-1]=0;
                    Operator[i]=0;
            }
            if(Operator[i]==1)
            {
                Num3[i]=Num4[i]*Num3[i-1]-Num4[i-1]*Num3[i];   //分子
                Num4[i]=Num4[i-1]*Num4[i];   //分母
                Num3[i-1]=0;
                Operator[i]=0;
            }
        }
        //输出
        Arrays.sort(Brace_position);  //括号位置排序
        for(int i=0;i<OperationNum;i++)
        {
            for(int y=0;y<x;y++)
            {
                if(Brace_position[y]==i)
                {
                    if(y<x/2)
                    {output=output+"(";}
                }
            }
            if(Num2[i]!=0&&Num2[i]!=1)
                {output=output+"(";}
            
            output=output+Num1[i];
            
            if(Num2[i]!=0&&Num2[i]!=1)
                {output=output+"/"+Num2[i]+")";}
            
            for(int y=0;y<x;y++)
            {
                if(Brace_position[y]==i)
                {
                    if(y>=x/2)
                    {output=output+")";}
                }
            }
            
            if(z[i+1]==0)
                {output=output+"+";}
            if(z[i+1]==1)
                {output=output+"-";}
            if(z[i+1]==2)
                {output=output+"*";}
            if(z[i+1]==3)
                {output=output+"/";}
        }
        output=output+"=";
        The_Fraction_In(Num3[OperationNum-1],Num4[OperationNum-1]);
        
    }
    public void Judge3(){     //判断是否符合参数(多项式运算,没有有分数)
        
          int j=0;
        
          for(int i=0;i<6;i++)
        {
            if(Brace_position[i]!=OperationNum)
                {j=1;break;}
            else
                {j=2;}
        }
          System.out.println("zhixingj:"+j);
        switch(j){
            case 1:Braces_polynomial();break; //包含括号的多项式的运算
            case 2:Arithmetic();break;        //没有括号的多项式的运算
        }
        
        
    }
    public void Judge4(){     //判断是否符合参数(多项式运算,有分数)
        
          int j=0;
        
          for(int i=0;i<6;i++)
        {
            if(Brace_position[i]!=OperationNum)
                {j=1;break;}
            else
                {j=2;}
        }
        switch(j){
            case 1:Braces_polynomial();break; //包含括号的多项式的运算
            case 2: Arithmetic();break;       //没有括号的多项式的运算
        }
    }
    public String OutputANDJudge(String s){    //对随机数进行判断,并保证随机题目的正确性
      //只有两个数运算且没有分数参与运算
      if(OperationNum==2&&Parameter[5]==1)
      {     
          Judge1();
      }
      //只有两个数运算但有分数参与运算
      else if(OperationNum==2&&Parameter[5]==0)
      {
          Judge2();
      }
     //有多个数运算且没有分数参与运算
      else if(OperationNum>2&&Parameter[5]!=0)
      {
          System.out.println("yunxing");
          Judge3();
      }
      //有多个数运算但有分数参与运算
      else
      {
          Judge4();
      }
      s=output;
      return s;
    }
    public String getAnswer(){
    return answer;
}
}


public class Run {
    public boolean NoSame(String s,String s1,int k){
        boolean flag=true;
        String s2=s;
        int start,end;
        for(int i=1;i<k;i++)
        {
            start=s2.indexOf(". ");
            end=s2.indexOf("\n");
            if(s1.equals(s2.substring(start+1,end-1)));
               {flag=false;}
             s2=s2.substring(end+1);
        }
        
        return flag;
    }
    public static void main(String[] args) {
        
        //可控参数
        int Remainder=3;
        Object[] options1={"有","没有"};
        int MultDiv=JOptionPane.showOptionDialog ( null, "请选择","题目是否有乘除法",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options1, options1[0] );
        
        Object[] options2={"有","没有"};
        int Parentheses=JOptionPane.showOptionDialog ( null, "请选择","题目是否有括号",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options2, options2[0] );
        
        Object[] options3={"0-100","0-200","0-300","0-500","0-1000","0-5000","0-10000"};
        int ValueRange=JOptionPane.showOptionDialog ( null, "请选择","取值范围",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options3, options3[0] );
        
        Object[] options4={"有","没有"};
        int Negative=JOptionPane.showOptionDialog ( null, "请选择","加减有无负数",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options4, options4[0] );
        
        if(MultDiv==0)
        {
            Object[] options5={"有","没有"};
            Remainder=JOptionPane.showOptionDialog ( null, "请选择","除法有无余数",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options5, options5[0] );
        }
        
        Object[] options6={"有","没有"};
        int Fraction=JOptionPane.showOptionDialog ( null, "请选择","题目中是否包含分数",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options6, options6[0] );
        //System.out.println(Fraction);
        //定制
        String inputValue1 = JOptionPane.showInputDialog("请输入要自动生成题目数量:");
        int Num=Integer.parseInt(inputValue1);
        String inputValue2 = JOptionPane.showInputDialog("请输入每行输出个数:");
        int PrintNum=Integer.parseInt(inputValue2);
        
        String s="";
        String s1="";
        String[] answer=new String[Num];
        //输出
        for(int i=0;i<Num;i++)
        {
            DateANDShow a=new DateANDShow(MultDiv,Parentheses,ValueRange,Negative,Remainder,Fraction);

            s=s+(i+1)+". ";
            a.Generate_random_number();
            s1=a.OutputANDJudge(s1);
            answer[i]=a.getAnswer();
            s=s+s1;
            
            //保持打印的格式,保持运算式一定的长度
            if(Parentheses==1)
            {
                for(int l=0;l<(10-s1.length());l++)
                {
                    s=s+" ";
                }
                
            }
            if(Parentheses==0)
            {
                for(int l=0;l<(40-s1.length());l++)
                {
                    s=s+" ";
                }
            }
            
            if((i+1)%PrintNum==0)   //换行打印
            {
                s=s+"\n";
            }
        }
        System.out.print(s);
        
        Object[] options7={"是","否"};
        int answerQuestion=JOptionPane.showOptionDialog ( null, "请选择","现在是否开始答题",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options7, options7[0] );
        if(answerQuestion==0)
        {
            for(int i=0;i<Num;i++)
            {
                String answer1= JOptionPane.showInputDialog("请输入第"+(i+1)+"题的答案:");
                if(answer1.equals(answer[i]))
                {
                    JOptionPane.showMessageDialog( null , "恭喜您答题正确!" ,"结果" , JOptionPane.ERROR_MESSAGE) ;
                }
                else
                {
                    JOptionPane.showMessageDialog( null , "很遗憾,您的答案不正确!正确答案为:"+answer[i] +"。","结果" , JOptionPane.ERROR_MESSAGE) ;
                }
            }
        }
        
    }
}

运行结果截图:

。。。答题过程就不一一列出了

没有括号,只有加减运算

多项式运算,加减乘除,不包含分数

多项式运算,包含分数且加减乘除且有括号(分数用括号以与除法区别)

编程总结分析:

这一次的编写,整合了以前所实现的功能,同时实现了两个新的功能,及答题并判断正误和打印进行对齐。这其中遇到了挺多难发现,难修改的bug。其中还是最常出现的错误:数组长度溢出。编写过程中要对数组的变化提高非常高的警惕。同时要对复杂的东西学会调用多个方法来实现。

合作开发工作照片:

PSP0级:

项目计划日志:

项目计划日志

姓名:范亚雷     日期:2016/03/21

时间/任务 听课 编写程序 阅读资料 准备考试     日总结
周日             0
周一 120   45       165
周二             0
周三   60 23       83
周四   85 15       100
周五   125 15       140
周六   240  20       260
周总结 120 510 118       748
阶段时间和效率                                                                                      周数:4
总计 120 510 118       748
平均 17 72.8 16.8       106.8
最大 120 240 45       260
最小 0 0 0       0
以前各周的累计时间
总计 180 600 610  748     2138
平均 180 600 610  748     2138
最大 180 600 610  748     2138
最小 180 600 610  748     2138

 

时间记录日志:

时间记录日志

学生:范亚雷                               日期:2016/03/21

教师:王建民                               课程:软件工程概论

日期 开始时间 结束时间 中断时间 净时间 活动 备注 c u
03/21 8:00 9:50   20 听课 软件工程概论    
  14:35 13:20   45 查阅资料 查阅java的数组排序    
03/23 19:03 19:45   42 编写程序  整理整体程序    
  19:45 20:08   23 查阅资料  查看方法化简    
  20:08 20:26   18 编写程序  继续优化方法    
03/24 19:00 19:25   25 编写程序  写入打印规格功能    
  19:25 19:40   15 查阅资料 查看网上的例子    
  19:40 20:40   60 编写程序 根据例子完成余下方法    
03/25 19:06 19:21   15 查阅资料      
  19:21 19:50   29 编写程序 完善程序    
  20:00 21:40   100 编写程序 继续    
03/26 13:15 17:25   240 编写程序 修改程序中的bug    

 

缺陷记录日志:

缺陷记录日志

学生:范亚雷                                      日期:03/21

日期 编号 类型 引入阶段 排除阶段 修复时间 修复缺陷
03/18 1   编码 译码 35  
描述:修改了程序中不能输出的问题
03/18 2   编码 译码 25  
描述:修改程序中只有两个运算数时,分数不能输出括号。
03/18 3   编码 译码 65  
描述:修改程序中有多个运算数时,实现计算括号内的,然后计算括号外面的。
03/19 4   编码 译码 65  
  描述:修改程序中判断方法不能正确使用
posted @ 2016-03-26 19:10  Fanyalei  阅读(209)  评论(0编辑  收藏  举报