zoukankan      html  css  js  c++  java
  • 结对编程作业(java)

    结对对象:许峰铭

    一.Github项目地址:https://github.com/Leungdc/Leungdc/tree/master/%E5%9B%9B%E5%88%99%E8%BF%90%E7%AE%97/ASMDframe

    二.PSP表格

    PSP2.1

    Personal Software Process Stages

    预估耗时(分钟)

    实际耗时(分钟)

    Planning

    计划

     560

     1440

    · Estimate

    · 估计这个任务需要多少时间

     120

     180

    Development

    开发

     2000

     2160

    · Analysis

    · 需求分析 (包括学习新技术)

     360

     360

    · Design Spec

    · 生成设计文档

     120

     180

    · Design Review

    · 设计复审 (和同事审核设计文档)

     60

     120

    · Coding Standard

    · 代码规范 (为目前的开发制定合适的规范)

     60

     90

    · Design

    · 具体设计

     150

     300

    · Coding

    · 具体编码

     2000

     2160

    · Code Review

    · 代码复审

     60

     60

    · Test

    · 测试(自我测试,修改代码,提交修改)

     300

     540

    Reporting

    报告

     120

     180

    · Test Report

    · 测试报告

     30

     30

    · Size Measurement

    · 计算工作量

     20

     20

    · Postmortem & Process Improvement Plan

    · 事后总结, 并提出过程改进计划

     20

     20

    合计

     5980

     7840

    三. 效能分析

    对于改进程序效能都是在刚开始构思该功能如何实现的时候想好的,通过实现改功能想法的相互对比,然后留下最好的方法,功能实现后就没有对方法进行很大的变动。在实现运算逻辑这一功能的时候是花费时间最多的,总共花费了两天的时间去实现这一功能,这一功能要考虑符号的优先级,包括括号和操作符等,由于使用的是栈存取数,要考虑存入的数据,和取出的方式。但栈只能先进后出,不能先取出头部数据,后改为用链栈进行数据的存储,从而使功能得以实现。

    为了提速而改变数据结构的耗时:≈总耗时*0.2

        1.该课设中大量使用StringBuilder类型数据而不是String是因为有对字符串频繁的增删查操作,节省了许多耗时

        2.查重算法中本是用出栈的方式一个一个出栈然后对比查重,但是考虑到时间较慢,就用了String类型数组来存放整个中间结果数据来对比查重

    最耗时函数:calculate()函数

        calculate函数是对两个数字的解析函数,因为操作符两边的数字使用String来存放的,首先calculate函数需要解析该数据的数据类型(是整数还是分数)

        然后化为假分数,再根据不同的操作符做不同的运算,其中该函数执行一次要调用至少六次其他方法。

    四.设计实现过程

     1.生成随机数算法

      生成随机数看似简单,但是涉及到的方法却不少,主要包括三种数 整数 带分数 真分数

      整数:直接用random方法生成

      带分数和分数:首先要将分子n和分母m分开生成,在这生成之间

        第一个要注意的点是:n%m!=0;1.屏蔽了分子和分母相等的情况  2.屏蔽了分子除与分母为整数的情况

        第二个要注意的点是:要对分子分母进行通分,我们的代码就使用了欧几里得方法求最大公约数,然后约分

        第三个要注意的点是:若n>m,则是带分数,先要用一个carrier来表示带分数的“带”,然后n=n%m;

        第四个要注意的点是:对于特别情况的屏蔽,例如m=1或m=0或n=0或carrier=0;都是不可取的

    2.两个数的运算

      只研究两个数的运算而不是三个数的运算,是因为在确定好运算逻辑的前提下,我们可以多次地调用运算两个数的方法,来得到我们最后的答案,下面介绍两个数运算的主要思路:

        1.采用假分数的计算方法;首先将所有的数转换成假分数如5=5/1,  6'7/8=55/8,  然后分别取这两个数的分子分母,根据不同的运算符,做不同的运算

        如:5÷6'7/8    第一步:5=5/1,n1=5,m1=1  6'7/8=55/8,n2=55 m2=8    第二步:N=n1*m2=5*8  M=m1*n2  最后再把n和m之间通分,若是带分数就转为带分数。

        由于这个运算方法要求可以服务于输出最终结果,所以运算的中间结果我们都用了题目要求的最终结果的格式(1或5'3/5或7/8)

    3.随机运算式的生成

        1.先生成随机个运算符n

        2.再生成随机个运算数字m

        3.在1和2的基础上插空生成括号

            经研究,包括无括号的情况,共有对于3个运算符一共有13种括号的生成可能,分别为:    

              一、1运算符2数字 不能生成括号

              二、2运算符3数字 只能是单括号,包含以下情况
                1. (1+2)+3
                2. 1+(2+3)

              三、3运算符4数字 单括号或双括号,包含以下情况

              单括号:
                3. (1+2)+3+4
                4. (1+2+3)+4
                5. 1+(2+3)+4
                6. 1+(2+3+4)
                7. 1+2+(3+4)

              双括号:
                8. (1+2)+(3+4)
                9. ((1+2)+3)+4
                10. (1+(2+3))+4
                11. 1+((2+3)+4)
                12. 1+(2+(3+4))

                13.1+2+3+4(无括号情况)

         我们采用枚举方式列出所有括号情况然后生成

     5.查重算法

       经过对四则运算的运算顺序的反复推敲后,我们得出了以下的运算优先级。

        靠左边的括号内运算>靠右边的括号内运算>最靠左的乘法运算=最靠左的除法运算>靠右的乘法运算=靠右的除法运算>从左至右运算>最靠左加法运算=最靠左减法运算>靠右的

    加法运算=靠右的减法运算;

       查重算法思路:

        ①从左至右扫描式子的第一个左括号,并记录位置,若无,则直接跳到③

        ②从左至右扫描式子的第一个右括号,截取①中左括号位置到②中第一个右括号位置之间的式子,并递归返回①,直到跳到③为止

        ③判断括号内(或无括号内)操作符的优先级高低,对最高优先级操作符的左右两边的数字进行运算,得到中间值,第一操作符a,将操作符和操作的两个数字压进过程栈,再判断

        括号内(或无括号内)次优先级的操作符是什么,再算出中间结果,再将操作符合操作的两个数字押进过程栈,最后对比所有式子的过程栈是否存在相同的,若有,则重新生成式子

        例如1+2+3的过程栈为+21+33;而3+2+1的过程栈为+32+51;又如3+(2+1)的过程栈为+21+33;与第一个式子的过程栈相同,则删掉重新生成式子。

    五.代码说明

     1.输入题目的数量num,和数字的范围range,调用GenerateEquation()生成式子,然后定义一个Calculator类对象并调用algorithm方法得到式子答案和式子的运算顺序,再用if语句判断返回答案是否为空,或式子的运算顺序已经存在,则重新生成式子。

     private  void CreatProblems(int num,int range) {
            
            Random rand=new Random();
            
        while(Count<num) {
                
        int[] operator=GenerateOpertor(operatorNum,rand); //随机生成operatorNum个字符        
            String equation=GenerateEquation(operator,operdataNum,range);       
            Calculator answer=new Calculator();
            list=answer.algorithm(equation);        
             if(!list.isEmpty()) {
                 String STR=Sb.toString();
                 if(STR.indexOf(list.get(1).toString())==-1) {
                     Sb.append(list.get(1)).append(" "); 
                    
                     problemTemp.append("第").append(Integer.toString(Count+1)).append("题:").append(equation).append("
    ");
                     
                     answerTemp[Count]=list.get(0).toString();                     
                      System.out.println(answerTemp[Count]); 
                     Count++;
                 }
             }else{
                 CreatProblems(num-Count,range);    
             }                 
           }
        }

     2.

    /*
         * 随机生成operatorNum个字符,并生成一个数组储存(下标数组)
         */    
        private  int[] GenerateOpertor(int operatorNum, Random rand) {    
            int[] operator=new int[operatorNum];
            for(int i=0;i<operatorNum;i++) {
                operator[i]=rand.nextInt(4);
            }
            return operator;    
        }

    3.

    /**
         * 生成随机数算法
         */
        
        private String getRandomNum(int limit){
            Random all = new Random();
            StringBuilder temp = new StringBuilder();
            int numtype = all.nextInt(2);
            int num = 0, carrier=0, numerator = 0, denominator = 0;
            int j = 0;
            if(numtype==0){
                num=1+all.nextInt(limit);
                return Integer.toString(num);
            }
            else{
                //此行生成分数
                numerator = 1+all.nextInt(limit);
                denominator = 2+all.nextInt(limit-1);        
                int n = numerator, m = denominator;
                if(n%m==0) {            //如果生成的分子分母不规范
                for(int i= 0 ; i<=100; i++){
                    n = 1+all.nextInt(limit);
                    m = 2+all.nextInt(limit-1);
                    if(n%m!=0) break;
                }
            }
                if(m>n)   j = Euclid(m, n);
                else{
                     carrier = n/m;
                     j = Euclid(n,m);        
                }
                if(j==1){                          //判断最大公约数是否等于1;
                    if(carrier!=0){                //判断该分数是不是假分数,是就转成带分数形式      
                        n=(n%m);
                        temp.append(carrier);
                        temp.append("'");
                        }
                    temp.append(n);
                    temp.append("/");
                    temp.append(m);
                    return temp.toString();
                }
                else{                    //判断该分数是不是假分数,是就转成带分数形式
                    n/=j;
                    m/=j;
                    if(carrier!=0){  
                        n=(n%m);
                        temp.append(carrier);
                        temp.append("'");
                    }
                    temp.append(n);
                    temp.append("/");
                    temp.append(m);
                    return temp.toString();            
                }
     
            }
    }
        
        /**
         * 欧几里得判断是否有公约数
         */
        private  int Euclid(int m,int n){
            while(n!=0){
                int r;
                r=m%n;
                m=n;
                n=r;
                Euclid(m,n);
                }
            return m;
            }

    4.用于计算式子的结果,计算逻辑在第四部分有逻辑图

    public class Calculator {
           public ArrayList algorithm(String str) { 
              LinkedList<String> numList=new LinkedList<>();//存放数字
              Stack<String> operatorStack=new Stack<>();//放操作符
              HashMap<String,Integer> hashMap=new HashMap<>();//存放字符优先级
              hashMap.put("(", 0);
              hashMap.put("+", 1);
              hashMap.put("-", 1);
              hashMap.put("*", 2);
              hashMap.put("÷", 2); 
              ArrayList list=new ArrayList();
              
              CheckOut check=new CheckOut();//生成运算顺序,用于查重 
              StringBuilder ba = new StringBuilder();
              
              String str1[]=str.split("\ ");//            for(String string:str1)//                    System.out.println(string);
                
                
                  int leftBrankets = 0;//用于检测‘(’的个数
                  int operatorCount=0;
                  
              for(int i=0;i<str1.length;i++) {
                 
                 
                  StringBuilder digit=new StringBuilder();
                  if(!"".equals(str1[i])) {
                     
                      //判断是否是数字
                      char num[]=str1[i].toCharArray();
                      if(Character.isDigit(num[0])) {
                          //                     System.out.println(str1[i]);                     
                         numList.addLast(String.valueOf(str1[i]));//压进数字栈
                         continue;//结束本次循环,回到for语句                         }
                      
                      //不是数字,是符号
                      else {
                         
                          char operatorOfChar=str1[i].charAt(0);
                          //                      System.out.println(operatorOfChar+"符号");
                          
                          switch(operatorOfChar) {
                          case '(':{
                              leftBrankets++;
                              break;
                          }
                          
                          case ')':{
                              String stmp;//取符号栈元素,考虑到(1+2*3)+4这种情况,要比较操作符的优先级                          String stmd;
                              if(!operatorStack.isEmpty()) {
                                  
                                  if(operatorCount==2&&leftBrankets==1) {
                                    //取出符号栈里的操作符(两个)
                                      stmp=operatorStack.pop();
                                      stmd=operatorStack.pop();
                                      if(hashMap.get(stmp)>hashMap.get(stmd)) {
                                          String a=numList.removeLast();
                                          String b=numList.removeLast();
                                          String result=calculate(b,a,stmp);
                                         
                                          if(result.contentEquals("出现了负值"))
                                              return list ;
                                          ba.append(check.checkOut(b, a, stmp));
                                        
                                          
                                          numList.push(result);//将结果压入栈
                                          operatorStack.push(stmd);//将未进行计算的操作符压回符号栈
                                          stmp = operatorStack.pop(); //符号指向下一个计算符号,再进行一次运算
                                          String c=numList.removeLast();
                                          String d=numList.removeLast();
                                          String result02=calculate(d,c,stmp);
                                          if(result02.contentEquals("出现了负值"))
                                              return list ;
                                          ba.append(check.checkOut(d, c, stmp));
                
                                          
                                          numList.push(result02);//将结果压入栈                                      
                                      }else {
                                          String a=numList.removeFirst();
                                          String b=numList.removeFirst();
                                          String result=calculate(a,b,stmd);
                                          if(result.contentEquals("出现了负值"))
                                              return list ;
                                          ba.append(check.checkOut(a, b, stmd));
                                        
                                          
                                          numList.addLast(result);
                                          operatorStack.push(stmp);
                                          stmp = operatorStack.pop(); //符号指向下一个计算符号
                                          String c=numList.removeLast();
                                          String d=numList.removeLast();
                                          String result02=calculate(d,c,stmp);
                                          if(result02.contentEquals("出现了负值"))
                                              return list ;
                                          ba.append(check.checkOut(d, c, stmp));
                                        
                                          
                                          numList.push(result02);//将结果压入栈                                  }
                                  }else if(leftBrankets==2||(operatorCount==1&&leftBrankets==1)){
                                      stmp=operatorStack.pop();
                                      String a=numList.removeLast();
                                      String b=numList.removeLast();
                                      String result=calculate(b,a,stmp);
                                      if(result.contentEquals("出现了负值"))
                                          return list ;
                                      ba.append(check.checkOut(b, a, stmp));
                                    
                                      numList.addLast(result);
                                      /*判定下一个str[i]是什么*/
                                      
                                  }
                                  break;  
                              }
                          }
                          
                          
                          case '=':{
                              String stmp;
                              while (!operatorStack.isEmpty()) { //当前符号栈里面还有+ - * /,即还没有算完
                                  stmp = operatorStack.pop();
                                  String a = numList.removeLast();
                                  String b = numList.removeLast();
                                  String result = calculate(b, a, stmp);
                                  if(result.contentEquals("出现了负值"))
                                      return list ;
                                  ba.append(check.checkOut(b, a, stmp));//                                  System.out.println(ba.toString());                                  
                                  numList.addLast(result);
                              }
                              break;
                          }
                          
                          default:{
                              operatorCount++;
                            String stmp;
                             while (!operatorStack.isEmpty()&&leftBrankets==0) { //如果符号栈有符号
                                 stmp = operatorStack.pop(); //当前符号栈,栈顶元素
                                 if (hashMap.get(stmp) >= hashMap.get(String.valueOf(operatorOfChar))) { //比较优先级
                                     String a = numList.removeLast();
                                     String b = numList.removeLast();
                                     String result =calculate (b, a, stmp);
                                     if(result.contentEquals("出现了负值"))
                                         return list ;
                                     ba.append(check.checkOut(b, a, stmp));
                                     numList.addLast(result);
                                 }else {
                                     operatorStack.push(stmp);
                                     break;
                                    }
                                 }
                             operatorStack.push(String.valueOf(operatorOfChar));
                             break;
                             }
                          
                          }
                          
                      }
                         
                  }
                        
              }
              list.add(numList.getLast());
              list.add(ba);
              
               return list; 
           }
           
    //       }
           /**
            * 计算结果
            */    
       private String calculate(String s1, String s2, String processor){
               int theinteger=0, theN=0, theM = 0;
               int position1 = -1,  position2 = -1;
               int  j = 1;   //放最大公约数
               String num1 = null, num2 =null;
               StringBuilder temp = new StringBuilder();
               int Nfornum1 = 0, Mfornum1 = 0, Nfornum2 = 0, Mfornum2 = 0;  
               int carrier1 = 0, carrier2 = 0;
               num1 = s1.substring(0);
               num2 = s2.substring(0);
               position1 = num1.indexOf("'");
               position2 = num1.indexOf("/");
               if(processor.equals("+")){
                   Mfornum1 = gettheM(num1);        //确定加号前面的数字的分母值(此处要保证该数字的最后一位元素是空格)
                   Nfornum1 = gettheN(num1, Mfornum1);    //确定加号后面的数字的分子值(此处要保证该数字的0号元素为数字,最后一位是空格(整数情况))
                   Mfornum2 = gettheM(num2);        //"2'4/21 "
                   Nfornum2 = gettheN(num2, Mfornum2);    //" 89"
                   theN = Nfornum1*Mfornum2+Nfornum2*Mfornum1;
                   theM = Mfornum1*Mfornum2;
                   if(theN>theM){
                       j=Euclid(theN,theM);
                       carrier1 = theN/theM;
                       }
                   else
                       j=Euclid(theM,theN);
                   theN/=j;
                   theM/=j;
                   if(theN%theM==0){
                       theN = theN/theM;
                       temp.append(Integer.toString(theN));
                   }
                   else{
                       if(carrier1!=0){                //判断该分数是不是假分数,是就转成带分数形式      
                           theN=(theN%theM);
                           temp.append(carrier1);
                           temp.append("'");
                           }
                       temp.append(Integer.toString(theN));
                       temp.append("/");
                       temp.append(Integer.toString(theM));
                   }
                   return temp.toString();
               }
               else if (processor.equals("-")){
                       Mfornum1 = gettheM(num1);        //确定加号前面的数字的分母值(此处要保证该数字的最后一位元素是空格)
                       Nfornum1 = gettheN(num1, Mfornum1);    //确定加号后面的数字的分子值(此处要保证该数字的0号元素为数字,最后一位是空格(整数情况))
                       Mfornum2 = gettheM(num2);        //"2'4/21 "
                       Nfornum2 = gettheN(num2, Mfornum2);    //" 89"
                       theN = Nfornum1*Mfornum2-Nfornum2*Mfornum1;
                       theM = Mfornum1*Mfornum2;
                       if(theN==0){
                           temp.append("0");
                           }
                       else if(theN>0){
                           if(theN>theM){
                               j=Euclid(theN,theM);
                               carrier1 = theN/theM;
                               }
                           else
                               j=Euclid(theM,theN);
                           theN/=j;
                           theM/=j;
                           if(theN%theM==0){
                               theN = theN/theM;
                               temp.append(Integer.toString(theN));                    }
                           else{
                               if(carrier1!=0){                //判断该分数是不是假分数,是就转成带分数形式      
                                   theN=(theN%theM);
                                   temp.append(carrier1);
                                   temp.append("'");
                                   }
                               temp.append(Integer.toString(theN));
                               temp.append("/");
                               temp.append(Integer.toString(theM));
                           }
                       }
                       else{
                           temp.append("出现了负值");
                           
                           }
               return temp.toString();
           }
               
               else if (processor.equals("*")){
                   Mfornum1 = gettheM(num1);        //确定加号前面的数字的分母值(此处要保证该数字的最后一位元素是空格)
                   Nfornum1 = gettheN(num1, Mfornum1);    //确定加号后面的数字的分子值(此处要保证该数字的0号元素为数字,最后一位是空格(整数情况))
                   Mfornum2 = gettheM(num2);        //"2'4/21 "
                   Nfornum2 = gettheN(num2, Mfornum2);    //" 89"
                   theN = Nfornum1*Nfornum2;
                   theM = Mfornum1*Mfornum2;
                   if(theN>theM){
                       j=Euclid(theN,theM);
                       carrier1 = theN/theM;
                       }
                   else
                       j=Euclid(theM,theN);
                   theN/=j;
                   theM/=j;
                   if(theN%theM==0){
                       theN = theN/theM;
                       temp.append(Integer.toString(theN));
                   }
                   else{
                       if(carrier1!=0){                //判断该分数是不是假分数,是就转成带分数形式      
                           theN=(theN%theM);
                           temp.append(carrier1);
                           temp.append("'");
                           }
                       temp.append(Integer.toString(theN));
                       temp.append("/");
                       temp.append(Integer.toString(theM));
                   }
                   return temp.toString();
               }
               else if (processor.equals("÷")){
                   Mfornum1 = gettheM(num1);        //确定加号前面的数字的分母值(此处要保证该数字的最后一位元素是空格)
                   Nfornum1 = gettheN(num1, Mfornum1);    //确定加号后面的数字的分子值(此处要保证该数字的0号元素为数字,最后一位是空格(整数情况))
                   Mfornum2 = gettheM(num2);        //"2'4/21 "
                   Nfornum2 = gettheN(num2, Mfornum2);    //" 89"
                   theN = Nfornum1*Mfornum2;
                   theM = Mfornum1*Nfornum2;    
                   if(theN>theM){
                       j=Euclid(theN,theM);
                       carrier1 = theN/theM;
                       }
                   else        j=Euclid(theM,theN);
                   theN/=j;
                   theM/=j;
                   if(theN%theM==0){
                       theN = theN/theM;
                       temp.append(Integer.toString(theN));
                   }
                   else{
                       if(carrier1!=0){                //判断该分数是不是假分数,是就转成带分数形式      
                           theN=(theN%theM);
                           temp.append(carrier1);
                           temp.append("'");
                           }
                       temp.append(Integer.toString(theN));
                       temp.append("/");
                       temp.append(Integer.toString(theM));//                   temp.append("
    ");               }
               return temp.toString();
               }
               else return "运算符号没有规范传入";
           }
           /**
            * 算结果的分子分母方法
            */
           private int gettheN(String beforeM,int M){
               int theN = 0;
               int position1 = -1, position2 = -1;
               position1 = beforeM.indexOf("/");
               position2 = beforeM.indexOf("'");
               if(position1<0&&position2<0){
                   try{
                       theN = theN + M * (Integer.parseInt(beforeM.substring(0)));
                   }  catch (NumberFormatException  e)    {
                       e.printStackTrace();
                   }
                   return theN;
           }
               else if(position1>0&&position2<0){        
                       try{
                           theN += Integer.parseInt(beforeM.substring(0,position1));
                       }  catch (NumberFormatException  e)    {
                           e.printStackTrace();
                       }
                       return theN;
               }
               else if(position1>0&&position2>0){
                   try{
                       theN = theN + M * (Integer.parseInt(beforeM.substring(0,position2)));
                   }  catch (NumberFormatException  e)    {
                       e.printStackTrace();
                   }
                   try{
                       theN += Integer.parseInt(beforeM.substring(position2+1,position1));
                   }  catch (NumberFormatException  e)    {
                       e.printStackTrace();
                   }
                   return theN;
           }
               else return -1;
           }
     
           private int gettheM(String afterN){
               int theM = 0;
               int position2  = -1;
               position2 = afterN.indexOf("/");
               int thezero = 0;
               if(position2>0){
                       try{
                           theM = Integer.parseInt(afterN.substring(position2+1));
                       }  catch (NumberFormatException  e)    {
                           e.printStackTrace();
                       }
               }
               else {
               theM=1;
               }
               return theM;
           }       
         
           private  int Euclid(int m,int n){
            while(n!=0){
                int r;
                r=m%n;
                m=n;
                n=r;
                Euclid(m,n);
                }
            return m;
            }

     5.用于生成运算式的子运算顺序式(格式:+ab(a>b))存进StringBuilder类并返回

    public class CheckOut {
         StringBuilder checkOut(String a,String b,String operator) {
             int aNum=0;
             int bNum=0;
             StringBuilder SB=new StringBuilder();
             //判断a,b分别是什么类型的数字
             int[] ajudge=judgeNum(a);
             int[] bjudge=judgeNum(b);
                  //比较a,b的大小
             if(ajudge[0]*bjudge[1]>bjudge[0]*ajudge[1]) {
                 //存进StringBuilder的顺序             SB.append(operator).append(a).append(b);
             }else {
                 SB.append(operator).append(b).append(a);
             }
            return SB;    
                
         }
         
     private int[] judgeNum(String str) {
             int position1=-1;
             int position2=-1;
             int[] Array = new int[3];//存分子分母         
            
             
             position1 = str.indexOf("/");
             position2 = str.indexOf("'");
             if(position1<0&&position2<0){//整数
                 Array[0]=Integer.valueOf(str);
                 Array[1]=1;
             }
             
             if((position1>0&&position2>0)||(position1>0&&position2<0)){//带分数或分数
                 String str1[]=str.split("\'|\/");
                int[] sons = new int[str.length()];
                 for(int i=0;i<str1.length;i++) {
                     sons[i]=Integer.parseInt(str1[i]);                 
                    }
                if(str1.length==3) {
                    Array[0]=sons[0]*sons[3]+sons[2];
                    Array[1]=sons[3];
                }else {                     
                    Array[0]=sons[0];
                    Array[1]=sons[1];
                }
             }
            return Array;         
         } 
         
    }
    六、测试运行

         测试用例1:题目个数num<=0或数字上限值<=1 结果:报错

         测试用例2:数目个数num=1000,正常的数字上限    结果:程序执行由3到5秒钟不等

         测试用例3:生成的答案文件或者成绩文件在指定目录存在同名同类型文件  结果:清除源文件信息,每次程序运行都更新文件信息

         测试用例4:生成100道式子,检查运算符个数的分布情况。结果:分布均匀

         测试用例5:生成100道式子,检查括号的分布情况。结果:分布均匀

         测试用例6:生成100道式子,检查不同数字类型的分布情况。结果:分布均匀

         测试用例7:特别地生成两个重复的式子,并进行查重   结果:查重成功,并成功删掉其一

         测试用例8:用户输入答案时输入特殊字符,结果:报错,错题+1

         测试用例9:用户只输入部分答案  结果:错题与对题统计无误

         测试用例10:正常生成式子与答案  结果:答案匹配

    八、项目小结

    我的结对对象是梁迪希同学
    做得好的方面:在程序刚开始的时候,我还没有什么头绪,迪希同学先有思路,然后共同讨论了查重这部分的实现方法,之后的两天时间里我们都是分开做,各有各自的思路,我的思路也清晰了,考虑到需要生成不同的式子类型,应该去怎么实现。到晚上的时候,我们也会交流各自的想法。迪希同学在功能的实现方面的想法是要比我多的,在我某些地方卡住的时候会分享他的想法给我,这是值得我学习的地方。
    做得不好的方面:在做项目的后段时间,由于时间的紧迫,我们各自分开实现不同的功能,但由于没能及时交流,使得功能之间没法很好地契合,所以花费了不少时间修整代码。往后在做类似团队项目时,要多交流,明确好分工,各自想法的优劣和各自项目功能的实现谁来做等。

  • 相关阅读:
    Maven 环境的配置
    zTree的简单例子
    plsql免安装客户端的配置
    HDU 1232 畅通工程
    HDU 5698 瞬间移动
    Codeforces 1015E1 Stars Drawing (Easy Edition)
    Codeforces 784B Santa Claus and Keyboard Check
    Codeforces 500C New Year Book Reading
    NSarray 赋值 拷贝 等问题记录
    UINavigationController 操作记录
  • 原文地址:https://www.cnblogs.com/dcLeung/p/11689716.html
Copyright © 2011-2022 走看看