软件工程个人作业02

题目描述：

设计思想：

   在第一次的基础上，加入三个条件。首先，对于问题不重复条件，我会在主类中加入一个NoSame的方法进行判断，随机生成的题目是否与之前生成的相同；其次，对于定制题目数量和打印方式，我会在主方法中加入控制；最后，对于5个可控参数，分别在另一个类中中去完成。对于是否有乘除法，主要是控制随机生成的代表的运算符的随机数是0、1还是0、1、2、3.对于是否有括号，则用一个随机数（2-10）产生是几个数运算，并加上括号。

对于加减有无负数，则对生成的题目判断，并修改。对于有无余数，则与前者相同。

源程序代码：

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


import javax.swing.JOptionPane;

class DateANDShow{
    int[] Parameter=new int[5];      //分别对应5个参数的一个长度为5的数组
    int[] z=new int[10];int z1;      //随机产生加减乘除的四则运算（0+；1-；2*；3/）
    int[] Big=new int[20];           //代表可能的多项式运算
    int Magnification;               //数值范围
    int OperationNum;                //有括号情况确定运算个数
    
    DateANDShow(){
    }
    
    DateANDShow(int a1,int a2,int a3,int a4,int a5){
        Parameter[0]=a1;     //代表是否有乘除法
        Parameter[1]=a2;     //代表是否有括号
        Parameter[2]=a3;     //代表取值范围
        Parameter[3]=a4;     //代表加减有无负数
        Parameter[4]=a5;     //代表除法有无余数
    }
    
    public void ChangeANDProduce(){
        //Change
        //确定题目中有无乘除
        if(Parameter[0]==0)
            z1=4;
        if(Parameter[0]==1)
            z1=2;
        //确定取值范围
        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;
        //确定计算个数
        if(Parameter[1]==0)
            OperationNum=(int)(Math.random()*9+2);
        if(Parameter[1]==1)
            OperationNum=2;    
        
        //Produce
        //产生运算数
        for(int i=0;i<OperationNum;i++)
        {
            Big[i]=(int)(Math.random()*Magnification);
            //随机确定是否为负数
            int t=(int)(Math.random()*10);
            if(t==9)
                Big[i]=-Big[i];
            //System.out.println(Big[i]);
        }
        //产生运算符
        for(int i=1;i<OperationNum;i++)
        {
            z[i]=(int)(Math.random()*z1);
            //System.out.println(z[i]);
        }
    }
    public String Judge1(String output){    //判断是否符合参数（只有加减法）
        if(z[1]==0)    //排除加法结果中是负数的情况
         {
            while(((Big[0]+Big[1])<0)&&(Parameter[3]==1))
                {
                   Big[0]=(int)(Math.random()*Magnification);
                   Big[1]=(int)(Math.random()*Magnification);
                }
            output=output+Big[0];
            output=output+"+";
         }
         if(z[1]==1)    //排除减法结果中是负数的情况
        {
             if(Big[1]>Big[0]&&Parameter[3]==1)
            {
                 int t=Big[1];
                 Big[1]=Big[0];
                 Big[0]=t;
            }
             output=output+Big[0];
             output=output+"-";
         }    
         
         if(z[1]==2)
         {
             output=output+Big[0];
             output=output+"*";
         }
         if(z[1]==3)     //排除除法为0和有余数的情况
        {
             while(Big[1]==0)
                 {Big[1]=(int)(Math.random()*Magnification);}
             
             if(Parameter[4]==1)
             {
                 while((Big[0]%Big[1]!=0)||(Big[1]==0))
                     {
                         Big[1]=(int)(Math.random()*Magnification+1);
                         Big[0]=(int)(Math.random()*Magnification);
                     }
             }        
            output=output+Big[0];
            output=output+"/"; 
        }
   
     output=output+Big[1]+"=";
        return output;
    }
    public String Judge2(String output){    //判断是否符合参数（加减乘除法）
        int k=Big[0];
        int[] sum =new int[10];    //计算中间值
        for(int i=0;i<10;i++)      //初始化为0
        {
            sum[i]=0;
        }
        
        if(Parameter[0]==0)   //有乘除的情况
        {
                for(int i=1;i<OperationNum;i++)
                {
                    if(z[i]==2)
                    {//System.out.println("*");
                        if(sum[i-1]==0)
                          {sum[i]=Big[i]*Big[i-1];}
                        else
                        {sum[i]=sum[i-1]*Big[i];}
                    }
                    if(z[i]==3)
                    {//System.out.println("/");
                        if(sum[i-1]==0)
                              {
                            while(Big[i]==0)
                                 {Big[i]=(int)(Math.random()*Magnification);}
                            if(Parameter[4]==1)
                             {
                                while((Big[i-1]%Big[i]!=0)||(Big[i]==0))
                                     {
                                         Big[i]=(int)(Math.random()*Magnification+1);
                                     }        
                            
                            sum[i]=Big[i-1]/Big[i];
                            }
                          }
                          else
                          {
                             while(Big[i]==0)
                                     {Big[i]=(int)(Math.random()*Magnification);}
                             if(Parameter[4]==1)
                                {
                                 while((sum[i-1]%Big[i]!=0)||(Big[i]==0))
                                     {
                                       Big[i]=(int)(Math.random()*Magnification+1);
                                     }
                                }    
                            sum[i]=sum[i-1]/Big[i];
                        }
                    }
                }
        }
        if(Parameter[3]==1)   //只有加减的情况
            {
                for(int i=1;i<OperationNum;i++)
                   {
                    if(z[i]==0&&Parameter[3]==1)               //加法无负数
                    {
                        while(k+Big[i]<0)
                        {
                            Big[i]=(int)(Math.random()*Magnification);
                        }
                        k=k+Big[i];
                    }
                    if(z[i]==1)              //减法无负数
                    {
                        while(k-Big[i]<0&&Parameter[3]==1)
                        {
                            Big[i]=(int)(Math.random()*Magnification);
                            int t=(int)(Math.random()*10);
                            if(t==9)
                                {Big[i]=-Big[i];}
                        }
                        k=k-Big[i];
                    }
                }
        }
        
        for(int i=1;i<OperationNum;i++)    //输出
        {
            output=output+Big[i-1];
            
            if(Parameter[1]==0&&i==3)
                output=output+")";
            
            if(z[i]==0)
                output=output+"+";
            if(z[i]==1)
                output=output+"-";
            if(z[i]==2)
                output=output+"*";
            if(z[i]==3)
                output=output+"/"; 
            
            if(Parameter[1]==0&&i==1)
                output=output+"(";
        }
        output=output+Big[OperationNum-1]+"=";
        
        return output;
    }
    public String OutputANDJudge(){    //对随机数进行判断，并保证随机题目的正确性
        String output="";
        //只有两个数运算
        if(OperationNum==2)
        {             
            output=Judge1(output);
        }
        //多个数进行运算
        else
        {
            //System.out.println(OperationNum);
            output=Judge2(output);
        }
       
        return output;
    }
}


public class Suiji {
    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("
");
            if(s1.equals(s2.substring(start+1,end-1)));
               {flag=false;}
             s2=s2.substring(end+1);
        }
        
        return flag;
    }
    public static void main(String[] args) {
        
        //可控参数
        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] );
        
        Object[] options5={"有","没有"};
        int Remainder=JOptionPane.showOptionDialog ( null, "请选择","除法有无余数",JOptionPane.YES_OPTION ,JOptionPane.PLAIN_MESSAGE,
                 null, options5, options5[0] );
        //定制
        String inputValue1 = JOptionPane.showInputDialog("请输入要自动生成题目数量：");
        int Num=Integer.parseInt(inputValue1);
        String inputValue2 = JOptionPane.showInputDialog("请输入每行输出个数：");
        int PrintNum=Integer.parseInt(inputValue2);
        
        String s="";
        String s1="";
        suiji b=new suiji();
        
        //输出
        for(int i=0;i<Num;i++)
        {
            DateANDShow a=new DateANDShow(MultDiv,Parentheses,ValueRange,Negative,Remainder);
            a.ChangeANDProduce();
            s=s+(i+1)+". ";
            s1=a.OutputANDJudge()+"  ";
            
            boolean flag=b.NoSame(s,s1,i);
            if(flag==true)
                 {s=s+s1;}
            else
                {i--;}
            
            if((i+1)%PrintNum==0)   //换行打印
            {
                s=s+"
";
            }
        }
        System.out.print(s);
        

    }

}

运行结果截图：

PSP0级：

项目计划日志：

项目计划日志

姓名：范亚雷     日期：2016/03/17

时间/任务 听课 编写程序 阅读资料 准备考试     日总结
周日             0
周一 120   45       165
周二             0
周三   65 15       80
周四   85 15       100
周五   125 10       135
周六   130         130
周总结 120 405 85       610
阶段时间和效率                                                                                      周数：3
总计 120 405 85       610
平均 17 58 12       87
最大 120 130 45       165
最小 0 0 10       0
以前各周的累计时间
总计 180 600 610       1390
平均 180 600 610       1390
最大 180 600 610       1390
最小 180 600 610       1390

时间记录日志：

时间记录日志

学生：范亚雷                               日期：2016/03/17

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

日期 开始时间 结束时间 中断时间 净时间 活动 备注 c u
03/14 8：00 9：50   20 听课 软件工程概论    
  14：35 13：20   45 查阅资料 查阅java的输出语句    
03/16 19：10 19：45   25 编写程序      
  19：45 20：00   15 查阅资料      
  20：00 20：45   45 编写程序      
03/17 19：00 19：15   15 编写程序      
  19：15 19：30   15 查阅资料 查看网上的例子    
  19：30 20：40   70 编写程序 完成整体程序    
03/18 19：05 19：15   10 查阅资料      
  19：15 19：50   35 编写程序 完善程序    
  20：00 21：30   90 编写程序 继续    
03/19 13：15 15：25   130 编写程序 修改程序中的bug    

缺陷记录日志：

缺陷记录日志

学生：范亚雷                                      日期：03/17

日期 编号 类型 引入阶段 排除阶段 修复时间 修复缺陷
03/18 1   编码 译码 35  
描述：修改了程序中不能输出括号
03/18 2   编码 译码 25  
描述：修改程序中只有两个运算数时，控制加减有误负数，除法有无余数。
03/18 3   编码 译码 65  
描述：修改程序中有多个运算数时，控制加减有误负数，除法有无余数。
03/19 4   编码 译码 65  
  描述：修改程序中判断题目是否相同方法
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/fan-xiaofan/p/5295576.html