结对伙伴：陈振华

 项目要求

　1.题目：实现一个自动生成小学四则运算题目的命令行程序。

　2.需求：　　

　　1. 使用 -n 参数控制生成题目的个数

　　2. 使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围。该参数可以设置为1或其他自然数。该参数必须给定，否则程序报错并给出帮助信息。

　　3. 生成的题目中计算过程不能产生负数，也就是说算术表达式中如果存在形如e1 − e2的子表达式，那么e1 ≥ e2。

　　4. 生成的题目中如果存在形如e1 ÷ e2的子表达式，那么其结果应是真分数。

　　5. 每道题目中出现的运算符个数不超过3个。

　　6. 程序一次运行生成的题目不能重复，即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。例如，23 + 45 = 和45 + 23 = 是重复的题目，6 × 8 　　= 和8 × 6 = 也是重复的题目。3+(2+1)和1+2+3这两个题目是重复的，由于+是左结合的，1+2+3等价于(1+2)+3，也就是3+(1+2)，也就是3+(2+1)。但是1+2+3和3+2+1是       不重复的两道题，因为1+2+3等价于(1+2)+3，而3+2+1等价于(3+2)+1，它们之间不能通过有限次交换变成同一个题目。

　　生成的题目存入执行程序的当前目录下的Exercises.txt文件

　　7. 在生成题目的同时，计算出所有题目的答案，并存入执行程序的当前目录下的Answers.txt文件

　　8. 程序应能支持一万道题目的生成。

　　9. 程序支持对给定的题目文件和答案文件，判定答案中的对错并进行数量统计

　Github项目地址：https://github.com/kvhong/Myapp

　设计

生成表达式：

1.通过命令行输入题目数量决定for循环的循环次数；输入数值大小决定表达式中整数、真分数分母分子的大小。

　2.调用FormExpression函数生成表达式并输出：用两个数组分别存储随机得到的整数分数和运算符。如果表达式中有除运算符，将数值数组中的整数分数从1开始生成，以解决出现除号右边结果为0的情况；如果表达式中有减号，则比较减号两边结果大小，在需要时进行交换，以解决生成负数结果。

　计算结果：

　1.先将上面生成的表达式(以字符串存储)处理为列表形式，再将此列表中的中缀表达式变换为后缀表达式，再用后缀表达式计算最终结果。

　2.计算过程：遍历后缀表达式列表，如果是数值存入栈中，如果是运算符则弹出栈中元素进行运算，再压入栈中。

　生成文件：

　1.将生成的表达式和结果分别用FileOutputStream存入Exercises.txt和Answers.txt文件中

　比较对错：

　1.用命令行输入试卷文件和答案文件，分别用InputStreamReader和BufferReader读取内容。

　2.取一行存入数组，取数组最后一个元素，加入数组中，然后对两个数组进行对比，以得到正确率。

　未完善问题

　1.处理减号时，仍会出现极少数负数问题，需重新构思实现。

　 2.未实现括号，由于先实现了表达式的输出，未即使同时实现括号的加入，现比较难加入。

　代码　　

　Fenshu：定义分数结构，并实现分数的加减乘除，其中包括了对两部分表达式的大小比较函数compute

分数类

　FormExpression：生成表达式

  1. import java.util.Random;
  2.  
  3. public class FormExpression {
  4.  
  5.     String FormExpression(int size , int operatenum) {
  6.         Random r = new Random();
  7.         String[] operate = {"+","-","×","÷"};
  8.         StringBuffer str = new StringBuffer();
  9.         StringBuffer strnew = new StringBuffer();
  10.         int num;
  11.         int numerator;
  12.         int denominator;
  13.         String oper;
  14.         Fenshu fenshu;
  15.         int divcount = 0;
  16.         String[] numlist = new String[operatenum+1];
  17.         String[] operlist = new String[operatenum];
  18.         for(int i=0;i<operatenum;i++) {
  19.             oper=operate[r.nextInt(4)];
  20.             operlist[i]=oper;
  21.             if(oper.equals("÷")) {
  22.                 divcount++;
  23.             }
  24.         }
  25.  
  26.         for(int i=0;i<operatenum+1;i++) {
  27.             if(divcount==0) {
  28.                 num=r.nextInt(size);
  29.                 numerator = r.nextInt(size);
  30.                 denominator = r.nextInt(size);
  31.             }else {
  32.                 num=r.nextInt(size)+1;
  33.                 numerator = r.nextInt(size)+1;
  34.                 denominator = r.nextInt(size)+1;
  35.             }
  36.             if(denominator!=0&&numerator<=denominator) {
  37.             fenshu = new Fenshu(numerator,denominator);
  38.             }else {
  39.                 fenshu = new Fenshu(denominator, numerator);
  40.             }
  41.             numlist[i]=randominput(num, fenshu);
  42.         }
  43.  
  44.         for(int i=0;i<2*operatenum+1;i++) {
  45.             if(i%2==0) {
  46.                 str.append(numlist[i/2]+" ");
  47.             }
  48.             if(i%2!=0) {
  49.                 str.append(operlist[(i-1)/2]+" ");
  50.             }
  51.         }
  52.         str.append("="+" ");
  53.  
  54.         String[] judge = str.toString().split(" ");
  55.             for(int i=1;i<judge.length-1;i+=2) {
  56.                 if(judge[i].equals("-")) {
  57.                     Fenshu fs = new Fenshu();
  58.                     Expression ex = new Expression();
  59.                     StringBuffer font = new StringBuffer();
  60.                     StringBuffer back = new StringBuffer();
  61.                     StringBuffer newstr = new StringBuffer();
  62.                     for(int k=0;k<i;k++) {
  63.                         font.append(judge[k]+" ");
  64.                     }
  65.                     for(int k=i+1;k<judge.length-1;k++) {
  66.                         back.append(judge[k]+" ");
  67.                     }
  68.                     Fenshu fontfs = ex.count(font.toString());
  69.                     Fenshu backfs = ex.count(back.toString());
  70.                     String fontstr = fontfs.numerator+"/"+fontfs.denominator;
  71.                     String backstr = backfs.numerator+"/"+backfs.denominator;
  72.                     if(fs.compute(fontstr, backstr)) {
  73.                         newstr.append(back.toString()+"- "+font.toString()+"= ");
  74.                         String[] newjudge = newstr.toString().split(" ");
  75.                         for(int k=0;k<newjudge.length;k++) {
  76.                             judge[k]=newjudge[k];
  77.                         }
  78.                     }
  79.                 }
  80.             }
  81.         for(int i=0;i<judge.length;i++) {
  82.             strnew.append(judge[i]+" ");
  83.         }
  84.         return strnew.toString();
  85.     }
  86.  
  87.     String randominput(int num,Fenshu fenshu) {
  88.         String numstr = num+"";
  89.         String fenshustr = fenshu.getNumerator() +"/"+fenshu.getDenominator();
  90.         String[] strlist = {numstr , fenshustr};
  91.         Random r = new Random();
  92.         return strlist[r.nextInt(2)].toString();
  93.     }
  94. }

生成表达式类

　Expression：计算结果

  1. import java.util.*;
  2. public class Expression {
  3.  
  4.     public char[] op = {'+','-','×','÷','(',')'};
  5.     public String[] strOp = {"+","-","×","÷","(",")"};
  6.     public boolean isDigit(char c){
  7.         if(c>='0'&&c<='9'){
  8.             return true;
  9.         }
  10.         return false;
  11.     }
  12.     public boolean isOp(char c){
  13.         for(int i=0;i<op.length;i++){
  14.             if(op[i]==c){
  15.                 return true;
  16.             }
  17.         }
  18.         return false;
  19.     }
  20.     public boolean isOp(String s){
  21.         for(int i=0;i<strOp.length;i++){
  22.             if(strOp[i].equals(s)){
  23.                 return true;
  24.             }
  25.         }
  26.         return false;
  27.     }
  28.     public boolean isFenshu(char c) {
  29.         if(c=='/') {
  30.             return true;
  31.         }
  32.         return false;
  33.     }
  34.  
  35.     //处理输入的计算式
  36.     public List<String> process(String str){
  37.         List<String> list = new ArrayList<String>();
  38.         char c;
  39.         StringBuilder sb = new StringBuilder();
  40.         for(int i=0;i<str.length();i++){
  41.             c = str.charAt(i);
  42.             if(isDigit(c)||isFenshu(c)){
  43.                 sb.append(c);
  44.  
  45.             }
  46.             if(isOp(c)){
  47.                 if(sb.toString().length()>0){
  48.                     list.add(sb.toString());
  49.                     sb.delete(0, sb.toString().length());
  50.                 }
  51.                 list.add(c+"");
  52.             }
  53.         }
  54.         if(sb.toString().length()>0){
  55.             list.add(sb.toString());
  56.             sb.delete(0, sb.toString().length());
  57.         }
  58.         return list;
  59.     }
  60.     public void printList(List<String> list){
  61.         for(String o:list){
  62.             System.out.print(o+" ");
  63.         }
  64.     }
  65.  
  66.     //一般计算式转换为后缀表达式
  67.     public List<String> simpleTosuffix(List<String> list){
  68.         List<String> Postfixlist = new ArrayList<String>();//存放后缀表达式
  69.         Stack<String> stack = new Stack<String>();//暂存操作符
  70.         for(int i=0;i<list.size();i++){
  71.  
  72.             String s = list.get(i);
  73.             if(s.equals("(")){
  74.                 stack.push(s);
  75.             }else if(s.equals("×")||s.equals("÷")){
  76.                 stack.push(s);
  77.             }else if(s.equals("+")||s.equals("-")){
  78.                 if(!stack.empty()){
  79.                     while(!(stack.peek().equals("("))){
  80.                         Postfixlist.add(stack.pop());
  81.                         if(stack.empty()){
  82.                             break;
  83.                         }
  84.                     }
  85.                     stack.push(s);
  86.                 }else{
  87.                     stack.push(s);
  88.                 }
  89.             }else if(s.equals(")")){
  90.                 while(!(stack.peek().equals("("))){
  91.                     Postfixlist.add(stack.pop());
  92.                 }
  93.                 stack.pop();
  94.             }else{
  95.                 Postfixlist.add(s);
  96.             }
  97.             if(i==list.size()-1){
  98.                 while(!stack.empty()){
  99.                     Postfixlist.add(stack.pop());
  100.                 }
  101.             }
  102.         }
  103.         return Postfixlist;
  104.     }
  105.  
  106.     //后缀表达式计算
  107.     public Fenshu count(String str){
  108.         List<String> list2 = process(str);
  109.         List<String> list = simpleTosuffix(list2);
  110.         Stack<Fenshu> stack = new Stack<Fenshu>();
  111.         for(int i=0;i<list.size();i++){
  112.             String s = list.get(i);
  113.             if(!isOp(s)){
  114.                 Fenshu fenshu;
  115.                 StringTokenizer tokenizer = new StringTokenizer(s, "/");
  116.                 int numerator = Integer.parseInt(tokenizer.nextToken());
  117.                 if(tokenizer.hasMoreTokens()) {
  118.                     int denominator = Integer.parseInt(tokenizer.nextToken());
  119.                     fenshu = new Fenshu(numerator, denominator);
  120.                 }else {
  121.                     fenshu = new Fenshu(numerator, -1);
  122.                 }
  123.                 stack.push(fenshu);
  124.             }else{
  125.                 if(s.equals("+")){
  126.                     Fenshu a1 = stack.pop();
  127.                     Fenshu a2 = stack.pop();
  128.                     Fenshu v = a2.add(a1);
  129.                     stack.push(v);
  130.                 }else if(s.equals("-")){
  131.                     Fenshu a1 = stack.pop();
  132.                     Fenshu a2 = stack.pop();
  133.                     Fenshu v = a2.sub(a1);
  134.                     stack.push(v);
  135.                 }else if(s.equals("×")){
  136.                     Fenshu a1 = stack.pop();
  137.                     Fenshu a2 = stack.pop();
  138.                     Fenshu v = a2.muti(a1);
  139.                     stack.push(v);
  140.                 }else if(s.equals("÷")){
  141.                     Fenshu a1 = stack.pop();
  142.                     Fenshu a2 = stack.pop();
  143.                     Fenshu v = a2.div(a1);
  144.                     stack.push(v);
  145.                 }
  146.             }
  147.         }
  148.         return stack.pop();
  149.     }
  150. }

计算结果类

　build：实现命令行题目数量和数值大小输入和输出表达式和答案到TXT文件

表达式和答案输出到TXT文件

  1. import java.io.File;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.util.Random;
  5. import java.util.Scanner;
  6.  
  7. public class build {
  8.     @SuppressWarnings("resource")
  9.     build() throws IOException {
  10.         Scanner scannernum;
  11.         Scanner scannersize;
  12.         int num=0;
  13.         int size=0;
  14.         FormExpression fe = new FormExpression();
  15.         Expression ex = new Expression();
  16.         Random r = new Random();
  17.         File que = new File("Exercises.txt");
  18.         File ans = new File("Answers.txt");
  19.         if(!que.exists()) {
  20.             que.createNewFile();
  21.         }
  22.         if(!ans.exists()) {
  23.             ans.createNewFile();
  24.         }
  25.         FileOutputStream fosque = new FileOutputStream(que);
  26.         FileOutputStream fosans = new FileOutputStream(ans);
  27.  
  28.             System.out.println("请输入要生成的题目数(命令形式为:-n 自然数):");
  29.             scannernum = new Scanner(System.in);
  30.             String[] strnum = scannernum.nextLine().split(" ");
  31.  
  32.             if(strnum[0].equals("-n")&&strnum.length==2) {
  33.                 if(Integer.parseInt(strnum[1])>=1) {
  34.                 num = Integer.parseInt(strnum[1]);
  35.  
  36.                 System.out.println("请输入题目中数值的最大值(命令形式为:-r 自然数):");
  37.                 scannersize = new Scanner(System.in);
  38.                 String[] strsize = scannersize.nextLine().split(" ");
  39.  
  40.                 if(strsize[0].equals("-r")&&strsize.length==2) {
  41.                     if(Integer.parseInt(strsize[1])>=2) {
  42.                     size = Integer.parseInt(strsize[1]);
  43.  
  44.                     for(int i=0;i<num;i++) {
  45.                         int opernum =  r.nextInt(3)+1;
  46.                         String res = fe.FormExpression(size, opernum);
  47.                         String result = i+1 + "." + res +"\r\n";
  48.                         byte[] print = result.getBytes();
  49.                         fosque.write(print);
  50.                         Fenshu ansresult = ex.count(res);
  51.                         String ansres = null;
  52.                         if(ansresult.getDenominator()==1) {
  53.                             ansres = i+1 + ". " +ansresult.getNumerator() + "\r\n";
  54.                         }else {
  55.                             if(ansresult.getNumerator()>ansresult.getDenominator()) {
  56.                                 int fz = ansresult.getNumerator();
  57.                                 int fm = ansresult.getDenominator();
  58.                                 int mut = fz / fm;
  59.                                 int newfz = fz % fm;
  60.                                 ansres = i+1 + ". " + mut + "'" +newfz+"/"+fm + "\r\n";
  61.                             }else if(ansresult.getNumerator()==ansresult.getDenominator()) {
  62.                                 ansres = i+1 + ". " + "1" + "\r\n";
  63.                             }else {
  64.                                 ansres = i+1 + ". " +ansresult.getNumerator()+"/"+ansresult.getDenominator() + "\r\n";
  65.                             }
  66.                         }
  67.                         byte[] ansprint = ansres.getBytes();
  68.                         fosans.write(ansprint);
  69.                         System.out.println(res);
  70.                         }
  71.                     fosque.flush();
  72.                     fosans.flush();
  73.                     fosque.close();
  74.                     fosans.close();
  75.                     }else {
  76.                         System.out.println("-r参数设置错误，请重新输入，-n参数必须大于等于2!");
  77.                     }
  78.                 }else {
  79.                     System.out.println("-r命令输入错误，请重新输入!");
  80.                 }
  81.                 }else {
  82.                     System.out.println("-n参数设置错误，请重新输入，-n参数必须大于等于1!");
  83.                 }
  84.             }else {
  85.                 System.out.println("-n命令输入错误，请重新输入!");
  86.             }
  87.     }
  88. }

　CorrectandWrong：命令行输入试卷文件和答案文件，判断对错并统计

  1. import java.io.BufferedReader;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.text.NumberFormat;
  7. import java.util.Scanner;
  8.  
  9. public class CorrectandWrong {
  10.  
  11.     private Scanner scanner1;
  12.     private Scanner scanner2;
  13.  
  14.     CorrectandWrong() throws IOException {
  15.         System.out.println("请输入试题文件名: ");
  16.         scanner1 = new Scanner(System.in);
  17.         String Exefile = scanner1.nextLine();
  18.         System.out.println("请输入答案文件名: ");
  19.         scanner2 = new Scanner(System.in);
  20.         String Ansfile = scanner2.nextLine();
  21.         File exefile = new File(Exefile);
  22.         File ansfile = new File(Ansfile);
  23.         if(exefile.exists()&&ansfile.exists()) {
  24.         InputStreamReader exread = new InputStreamReader(new FileInputStream(Exefile), "GB2312");
  25.         BufferedReader exbr = new BufferedReader(exread);
  26.         InputStreamReader anread = new InputStreamReader(new FileInputStream(Ansfile), "GB2312");
  27.         BufferedReader anbr = new BufferedReader(anread);
  28.         String ex;
  29.         String an;
  30.         String exback = null;
  31.         String anback = null;
  32.         String[] exlist = null;
  33.         String[] anlist = null;
  34.         String[] Exercises = null;
  35.         StringBuffer exercises = new StringBuffer();
  36.         String[] Answers = null;
  37.         StringBuffer answers = new StringBuffer();
  38.         int correctnum = 0;
  39.         int wrongnum = 0;
  40.         StringBuffer correct = new StringBuffer();
  41.         StringBuffer wrong = new StringBuffer();
  42.         while((ex=exbr.readLine())!=null) {
  43.             exlist = ex.split(" ");
  44.             if(exlist[exlist.length-1].equals("=")) {
  45.                 exback = "-";
  46.             }else {
  47.                 exback = exlist[exlist.length-1];
  48.             }
  49.             exercises.append(exback+",");
  50.         }
  51.         Exercises = exercises.toString().split(",");
  52.         while((an=anbr.readLine())!=null) {
  53.             anlist = an.split(" ");
  54.             anback = anlist[anlist.length-1];
  55.             answers.append(anback+",");
  56.         }
  57.         Answers = answers.toString().split(",");
  58.         for(int i=0;i<Exercises.length;i++) {
  59.             if(Exercises[i].equals(Answers[i])) {
  60.                 correct.append(i+1+" ");
  61.                 correctnum++;
  62.             }else {
  63.                 wrong.append(i+1+" ");
  64.                 wrongnum++;
  65.             }
  66.         }
  67.         System.out.println("Correct: "+correctnum+" ( "+correct+")");
  68.         System.out.println("Wrong: "+wrongnum+" ( "+wrong+")");
  69.         NumberFormat nt = NumberFormat.getPercentInstance();
  70.         nt.setMinimumFractionDigits(2);
  71.         double correctpercent = (double) correctnum / (double) Exercises.length;
  72.         double wrongpercent = (double) wrongnum / (double) Exercises.length;
  73.         System.out.println("正确率: "+nt.format(correctpercent));
  74.         System.out.println("错误率: "+nt.format(wrongpercent));
  75.         exread.close();
  76.         anread.close();
  77.         exbr.close();
  78.         anbr.close();
  79.         }else {
  80.             System.out.println("找不到指定文件!");
  81.         }
  82.     }
  83. }

判断对错并统计

　Myapp：主函数只用while持续调用build类和CorrectandWrong类，此处不展示。

　测试

　表达式输出

　以50条表达式，数值小于10为例(可实现10000条表达式)：

  1. 1.2/9 × 6 × 8 - 2/9 =
  2. 2.2 - 1 ÷ 1 - 1/5 =
  3. 3.2 × 5 + 0 =
  4. 4.9 - 6 - 1/9 =
  5. 5.1/1 ÷ 2 =
  6. 6.2 - 3/8 - 1/6 × 0/1 =
  7. 7.7 - 1/2 =
  8. 8.9 ÷ 2/3 =
  9. 9.3/7 × 3 - 7 × 0/1 =
  10. 10.1/4 + 3/7 × 7 - 2/7 =
  11. 11.1 - 0/1 =
  12. 12.2 - 1/8 + 5/6 =
  13. 13.1/2 - 2/7 - 0/1 × 1/4 =
  14. 14.0 + 5 + 1/1 =
  15. 15.5 + 0 =
  16. 16.9 - 5 =
  17. 17.1/2 + 1/3 + 2 ÷ 3/5 =
  18. 18.2/3 ÷ 3 =
  19. 19.3 - 3/4 - 5/9 =
  20. 20.5 + 0/1 × 8 =
  21. 21.1/1 ÷ 1/2 + 10 ÷ 7 =
  22. 22.7 × 1/1 + 2/7 - 1 =
  23. 23.5 × 8 - 8 =
  24. 24.1/2 + 7 × 1/9 × 5 =
  25. 25.1/1 ÷ 5 + 1 =
  26. 26.6 - 5 =
  27. 27.8 ÷ 5/9 ÷ 2/3 =
  28. 28.3 - 0/1 =
  29. 29.2 + 1 - 8/9 =
  30. 30.3/7 ÷ 3 × 1 ÷ 1 =
  31. 31.6 × 2/3 =
  32. 32.4 + 2 ÷ 5 =
  33. 33.2/3 × 2 ÷ 3 =
  34. 34.6 - 1/8 + 3/4 ÷ 1/5 =
  35. 35.7 - 4/7 + 0 =
  36. 36.4 ÷ 10 ÷ 2/9 =
  37. 37.1/2 × 3 - 1/1 =
  38. 38.6 ÷ 1/7 =
  39. 39.1 ÷ 3 × 5 + 6 =
  40. 40.0 + 3 × 6/7 =
  41. 41.2/3 + 7 =
  42. 42.3/5 - 9 × 0 + 1/3 =
  43. 43.2/9 ÷ 1/2 + 1/7 ÷ 4 =
  44. 44.2 - 5/7 =
  45. 45.1 + 1/4 ÷ 9 + 1/9 =
  46. 46.5 ÷ 1/2 - 4 =
  47. 47.2 ÷ 4 - 4/9 =
  48. 48.1/1 - 2/9 × 3/8 =
  49. 49.1/6 - 0 - 1/9 =
  50. 50.1/1 + 0/1 =

　答案：

  1. 1. 10'4/9
  2. 2. 4/5
  3. 3. 10
  4. 4. 2'8/9
  5. 5. 1/2
  6. 6. 1'5/8
  7. 7. 6'1/2
  8. 8. 13'1/2
  9. 9. 1'2/7
  10. 10. 2'27/28
  11. 11. 1
  12. 12. 2'17/24
  13. 13. 3/14
  14. 14. 6
  15. 15. 5
  16. 16. 4
  17. 17. 4'1/6
  18. 18. 2/9
  19. 19. 1'25/36
  20. 20. 5
  21. 21. 3'3/7
  22. 22. 6'2/7
  23. 23. 32
  24. 24. 4'7/18
  25. 25. 1'1/5
  26. 26. 1
  27. 27. 9'3/5
  28. 28. 3
  29. 29. 2'1/9
  30. 30. 1/7
  31. 31. 4
  32. 32. 4'2/5
  33. 33. 4/9
  34. 34. 9'5/8
  35. 35. 6'3/7
  36. 36. 4/45
  37. 37. 1/2
  38. 38. 42
  39. 39. 6'1/15
  40. 40. 2'4/7
  41. 41. 7'2/3
  42. 42. 14/15
  43. 43. 121/252
  44. 44. 1'2/7
  45. 45. 1'5/36
  46. 46. 6
  47. 47. 1/18
  48. 48. 11/12
  49. 49. 1/18
  50. 50. 1

　判断对错并统计：以上面50条为例，将其中10条填入正确答案，其他为空，随机分布在50条表达式中：

　PSP

PSP2.1 Personal Software Process Stages 预估耗时（分钟） 实际耗时（分钟）
Planning 计划 120 210
· Estimate · 估计这个任务需要多少时间 120 210
Development 开发 3170 4420
· Analysis · 需求分析 (包括学习新技术) 90 180
· Design Spec · 生成设计文档 120 200
· Design Review · 设计复审 (和同事审核设计文档) 80 120
· Coding Standard · 代码规范 (为目前的开发制定合适的规范) 40 60
· Design · 具体设计 120 200
· Coding · 具体编码 2400 3000
· Code Review · 代码复审 120 300
· Test · 测试（自我测试，修改代码，提交修改） 200 360
Reporting 报告 190 220
· Test Report · 测试报告 100 120
· Size Measurement · 计算工作量 30 20
· Postmortem & Process Improvement Plan · 事后总结, 并提出过程改进计划 60 80
合计   3480 4850

　总结

　在这次的结对编程中，真正体会到了两个人不同思想的碰撞，虽然你一开始想出来的方法可行，但是别人想出来的可能更加的简便易实现。所以多跟他人交流沟通会有很大的收获。在这过程中，我和结对伙伴就生成表达式过程中该如何存储，如果结果为负数在生成过程中该如何实现不生成负数结果的表达式，分数的实现和计算，括号的优先运算，后缀表达式的实现进行了较深入的探讨。陈振华同学也针对我的编码风格和代码简约程度提出了批评意见，我也认识到这一点，需认真学习代码编写的简约清晰化，在后面的代码编写中更加注意这些问题。

结对编程-四则运算生成器(java实现)的更多相关文章

  1. 结对编程--四则运算（Java）萧英杰 夏浚杰

    结对编程--四则运算(Java)萧英杰 夏浚杰 Github项目地址 功能要求 题目:实现一个自动生成小学四则运算题目的命令行程序 使用 -n 参数控制生成题目的个数(实现) 使用 -r 参数控制题目 ...

  2. 结对编程--四则运算（Java）梅进鹏 欧思良

    结对编程--四则运算(Java)梅进鹏 欧思良 Github项目地址:https://github.com/MeiJinpen/Arithmetic 功能要求 题目:实现一个自动生成小学四则运算题目的 ...

  3. 结对编程 四则运算（java）（胡大华 黄绪明）

    Github项目地址 https://github.com/yogurt1998/Myapp 项目需求 题目: 实现一个自动生成小学四则运算题目的命令行程序 功能 1.使用-n 参数控制生成题目的个数 ...

  4. 20175226 2018-2019-2《java程序设计》结对编程-四则运算（第一周-阶段总结）

    结对编程-四则运算(第一周-阶段总结) 需求分析 实现一个四则运算程序,要求: 自动随机生成小学四则运算题目(加,减,乘,除) 支持整数.真分数且支持多项式 能够利用栈的思想,将中缀转换为后缀表达式 ...

  5. 20175305张天钰Java结对编程四则运算（二）

    Java结对编程四则运算(二) 一.题目描述及要求 Git提交粒度不要太粗,建议一个文件/一个类/一个函数/一个功能/一个bug修复都进行提交,不能一天提交一次,更不能一周一次,参考Commit Me ...

  6. 20175305张天钰Java结对编程四则运算

    Java结对编程四则运算 一.题目描述:如何对表达式进行求值运算呢 1.中缀表达式与后缀表达式(娄老师讲解) 中缀表达式就是运算符号在运算数中间的表达式,比如1+2,顾名思义,后缀表达式就是运算符在运 ...

  7. Java结对编程四则运算一周小结

    Java结对编程四则运算一周小结 需求分析 对于四则运算来说最主要的就是要计算出产生的式子(字符串的形式). 设计思路 总体可将这个项目分解为几个部分:产生式子,计算式子,判断对错并记录: 具体的思路 ...

  8. 王译潇20162314 实验报告三plus结对编程四则运算第一阶段

    北京电子科技学院BESTI实验报告 课程:程序设计与数据结构 班级: 1623 姓名: 王译潇 学号:20162314 指导教师:娄佳鹏老师.王志强老师 实验日期:2017年5月12号 实验密级: 非 ...

  9. 结对编程1----基于java的四则运算生成器

    小组成员:王震(201421123054).王杰(201421123055) Coding地址:https://git.coding.net/a506504661/sssss.git 一.题目描述 我 ...

随机推荐

  1. 首届阿里巴巴在线技术峰会，9位大V演讲整理！

    https://yq.aliyun.com/articles/57826 感谢参加阿里巴巴在线技术峰会.7月19日的3场专家分享:Blink.Docker.电商互动:7月20日的云数据库十大经典案 例 ...

  2. centos7 端口转发

    firewall-cmd --add-masquerade   firewall-cmd --add-forward-port=port=3001:proto=tcp:toaddr=172.17.18 ...

  3. Null Hypothesis and Alternate Hypothesis

    1.Null Hypothesis Overview 零假设,H0是普遍接受的事实;这与备择假设(alternate hypothesis)正好相反.研究人员努力否定.驳斥零假设.研究人员提出了另一种 ...

  4. 如何禁止浏览器自动填充非登陆input的账号和密码？

    发现浏览器填充密码的方式,那就是,找到页面上第一个type为password的input填充.发现了这个规律后,很自然的就想到了,是不是可以在真正的password前面加一个隐藏的password,形 ...

  5. VB 共享软件防破解设计技术初探（一）

    VB 共享软件防破解设计技术初探(一) ×××××××××××××××××××××××××××××××××××××××××××××× 其他文章快速链接: VB 共享软件防破解设计技术初探(二)http ...

  6. 使用百度网盘配置私有Git服务

    GitHub上免费的版本只能开源代码库,有时候需要配置些私有的服务,不方便公开.现在免费的网盘的容量越来越大,可以用来做存储的服务,如果只使用网盘存储合并代码很不方便,所以使用网盘+git 配置私有仓 ...

  7. python版本安装

    目的 本文目的在于,对于不熟悉Python的人,教你: 1. 从哪里找到 可以下载到 各种版本的 包括Python 2.x和Python 3.x的 最新版本的 Python. 高手请无视之. 2.以及 ...

  8. 两个应用之间传递广播的规则 Broadcast

    sendBroadcast(new Intent(Config.ACTION_PRINT),”com.qf.permission.print”);先判断应用有没有对应的权限 再去判断有没有对应的act ...

  9. Broadcast总结 service

    有时候离开应用就会接收不到系统的广播是因为系统默认发送的广播都会有一个参数 ntent startIntent = new Intent();startIntent.putExtra("pk ...

  10. discuz目录结构和插件创建

    discuz目录结构 api 外部接口功能实现 archiver 静态文档,静态化所用 config 配置 data 生成的数据 install 安装目录 source 源代码核心目录 |--modu ...