结对编程作业（JAVA实现）
github地址：https://github.com/IMFatDragon/sizeyunsuan.git
完成者：
周惠龙 3117004638
陈浩峰 3117004603
一、项目相关要求
- 使用 -n 参数控制生成题目的个数，例如 SiZeYunSuan.exe -n 10 将生成10个题目。（完成）
- 使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围，例如SiZeYunSuan.exe -r 10 将生成10以内（不包括10）的四则运算题目。（完成）
- 生成的题目中计算过程不能产生负数，即算术表达式中如果存在形如e1 − e2的子表达式，必须e1 ≥ e2。（完成）
- 生成的题目中如果存在形如e1 ÷ e2的子表达式，那么其结果应是真分数。（完成）
- 每道题目中出现的运算符个数不超过3个。（完成）
- 程序一次运行生成的题目不能重复，即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。（完成）
- 生成的题目存入执行程序的当前目录下的Exercises.txt文件，格式如下：（完成）
1. 四则运算题目1
2. 四则运算题目2
……
其中真分数在输入输出时采用如下格式，真分数五分之三表示为3/5，真分数二又八分之三表示为2'3/8。
- 在生成题目的同时，计算出所有题目的答案，并存入执行程序的当前目录下的Answers.txt文件，格式如下：（完成）
1. 答案1
2. 答案2
特别的，真分数的运算如下例所示：1/6 + 1/8 = 7/24。
- 程序应能支持一万道题目的生成（完成）
- 程序支持对给定的题目文件和答案文件，判定答案中的对错并进行数量统计，输入参数如下：（未完成）
Myapp.exe -e .txt -a .txt 统计结果输出到文件Grade.txt，
格式如下： Correct: 5 (1, 3, 5, 7, 9)Wrong: 5 (2, 4, 6, 8, 10)
二、需求分析
从整体需求来看，大致可以分成三个模块：表达式生成模块、表达式运算模块、运算结果检验模块。
- 表达式生成模块：表达式包括运算符部分（加减乘除）、数字部分（自然数，真分数，带分数）、括号部分。数值部分利用random对象的nextInt方法随机从1开始生成，其中分子随机数的数值范围是比分母小1，保证生成的数字不出现假分数的情况；运算符的个数是利用函数随机生成1-3之间的自然数，加减乘除的符号也是利用随机数1-4来生成；符号部分利用next Boolean方法根据true或者false来决定括号的生成，该过程中利用一个变量来标记括号范围。
- 表达式运算模块：上述模块生成的表达式只是初步的表达式，运算功能是利用后缀表达式来实现的，生成后缀表达式后再将表达式的所有数值转化为分数形式，统一方便计算。为保证该过程中不出现负数运算，凡是进行减法运算的操作，都会对运算结果进行检验，一旦出现负数则丢弃当前表达式，直到再次生成的表达式符合要求，同时在此过程进行表达式的重复判断，将每一个当前非负表达式与已生成表达式进行查重检验，满足条件则加入Arraylist中，同时保存运算结果。
- 查重检验：将后缀表达式转换为查重表达式，查重表达式的结果为运算符在先，后面跟着该运算符的操作数，例如（1+2）*3-4，后缀表达式为：12+3*4-，按照查重表达式的结构为：+12*3-4，查重过程中只需要判断查重表达式是否一致，或者在查重表达式中第一个字符'+'或'*'的情况下后续的两个操作数交换位置后是否一致即可。也就是说+12*3-4与+21*3-4的表达式是一致的。举个表达式不重复的例子：1+2+3和3+2+1，查重表达式分别为+12+3和+32+1，查重表达式不相同，即使交换'+'后面的两个操作数也无法一致，故这两个表达式不重复。
- 运算结果检验模块：将最终符合要求的表达式存入当前目录下的Question.txt文件，正确答案保存在Answer.txt文件中，并对运算结果进行检。
三、设计思路
1.整体结构：
2.生成表达式：
四、模块代码说明
1、随机生成表达式：
1 package Calculation; 2 3 import java.util.ArrayList; 4 import java.util.Random; 5 import java.util.Scanner; 6 7 8 public class Ran_Expression { //随机生成初步的表达式 9 10 11 12 public static char[] ysf={'+','-','*','÷'}; 13 public static String exp_str;//四则运算表达式 14 15 //获取输入 16 public static String getScanner(){ 17 Scanner scan=new Scanner(System.in); 18 String input=scan.nextLine(); 19 scan.close(); 20 return input; 21 } 22 23 24 //随机获取运算符+ - * ÷ 25 public static char getysf(){ 26 Random ran=new Random(); 27 int ysfNum=ran.nextInt(4); 28 return ysf[ysfNum]; 29 } 30 31 /** 32 * 获取操作数 33 * @param range 数值范围 34 * @return 35 */ 36 public static String getNumber(int range){ 37 Random ran=new Random(); 38 int index=ran.nextInt(3); 39 String num=""; 40 41 /** 42 * 随机获取数字，0获取自然数，1获取真分数，2获取带分数 43 */ 44 if(index==0){//自然数 45 Random ran0=new Random(); 46 num=ran0.nextInt(range-1)+1+""; 47 } 48 if(index==1){//真分数 49 Random ran1=new Random(); 50 int fenmu=ran1.nextInt(range-2)+2;//分母[2,range) 51 int fenzi=ran1.nextInt(fenmu-1)+1;//分子 52 num=fenzi+"/"+fenmu+""; 53 } 54 if(index==2){//带分数 55 Random ran2=new Random(); 56 int leftNum=ran2.nextInt(range-1)+1;//左整数部分 57 int rightFM=ran2.nextInt(range-2)+2;//右真分数部分-分母[2,range) 58 int rightFZ=ran2.nextInt(rightFM-1)+1;//右真分数部分-分子 59 num=leftNum+"'"+rightFZ+"/"+rightFM+""; 60 } 61 return num; 62 } 63 64 /** 65 * 去表达式最前和最后的括号 66 * @param str表达式 67 * @return 68 */ 69 public static String deleteKuoHao(String str){ 70 if((str.substring(0, 1).equals("(")) && (str.substring(str.length()-1).equals(")"))){ 71 str=str.substring(1, str.length()-1); 72 } 73 return str; 74 } 75 76 77 //生成四则运算表达式 78 //range题目中操作数的范围 79 public static ArrayList<String> creatAc(int range){ 80 Random ran4=new Random(); 81 ArrayList<String> list=new ArrayList<String>();//存放每个表达式中的运算符和操作数 82 boolean zuoKuoHao=false;//左括号 83 boolean youKuoHao=false;//右括号 84 boolean tem=false; 85 int ysfNum=ran4.nextInt(3)+1;//每个表达式运算符个数1-3个 86 exp_str=""; 87 88 //------------开始生成-------------- 89 for(int j=0;j<ysfNum;j++){ 90 91 //决定是否加入左括号 92 if(!zuoKuoHao && ran4.nextBoolean()){ 93 exp_str+="("; 94 list.add("("); 95 zuoKuoHao=true; 96 } 97 String sz1=getNumber(range); 98 exp_str+=sz1; 99 list.add(sz1); 100 //决定是否加入右括号 101 if(zuoKuoHao && !youKuoHao && tem){ 102 if(ran4.nextBoolean()){ 103 exp_str+=")"; 104 list.add(")"); 105 youKuoHao=true; 106 } 107 } 108 char char1=getysf(); 109 exp_str+=char1; 110 list.add(char1+""); 111 if(zuoKuoHao){ 112 tem=true; 113 } 114 } 115 String sz2=getNumber(range); 116 exp_str+=sz2; 117 list.add(sz2); 118 if(zuoKuoHao && !youKuoHao){ 119 exp_str+=")"; 120 list.add(")"); 121 } 122 exp_str=deleteKuoHao(exp_str);//去掉开头和结尾均为括号 123 //------------结束生成-------------- 124 125 System.out.println("生成中，请稍等："+exp_str); 126 return list; 127 128 } 129 130 131 132 }
2、生成后缀表达式：
1 package Calculation; 2 3 import java.util.ArrayList; 4 import java.util.Stack; 5 6 7 public class After_Expression { //生成后缀表达式 8 /** 9 * 将中序表达式转换成后序表达式 10 * @param str 生成的中序表达式 11 */ 12 public static Stack<String> toAfter_Expression(ArrayList<String> list){ 13 Stack<String> stack=new Stack<String>();//栈 14 Stack<String> right=new Stack<String>();//右序表达式 15 String ysf;//运算符 16 17 for(int i=0;i<list.size();i++){ 18 String ch=list.get(i); 19 if(isysf(ch)){//当前字符为运算符 20 if(stack.empty()==true || ch=="("){//栈为空或者为（直接入栈 21 stack.push(ch); 22 }else{//非栈空、非左括号 23 if(ch==")"){//如果为） 24 while(true){//将（后的运算符出栈并加到后续表达式中 25 if((!stack.empty()) && (!stack.peek().equals("("))){ 26 ysf=stack.pop(); 27 right.push(ysf); 28 }else{ 29 if(!stack.empty())//如果栈顶元素为（ 30 stack.pop(); 31 break; 32 } 33 } 34 }else{//非栈空、非左括号、非右括号 35 while(true){//栈不为空，优先级低 36 if(!stack.empty() && priority(ch,stack.peek())){ 37 ysf=stack.pop()+""; 38 if(!ysf.equals("(")){ 39 right.push(ysf); 40 } 41 }else{ 42 break; 43 } 44 } 45 stack.push(ch+""); 46 } 47 } 48 49 }else{ 50 right.push(ch+"");//操作数 51 } 52 } 53 while(!stack.empty()){ 54 ysf=stack.pop()+""; 55 if(!ysf.equals("(")) 56 right.push(ysf); 57 } 58 return right; 59 } 60 61 62 // 判断是否为运算符 63 public static boolean isysf(String ch){ 64 if((ch.equals("+"))||(ch.equals("-"))||(ch.equals("*"))||(ch.equals("÷"))||(ch.equals("("))||(ch.equals(")"))) 65 return true; 66 else 67 return false; 68 } 69 70 /** 71 * 设置运算符的优先级别 72 * @param ysfout当前中序表达式字符 73 * @param ysfin栈中字符 74 * @return 75 */ 76 public static boolean priority(String ysfout, String ysfin) { 77 int m = -1, n = -1; 78 String a_ysf[][] = { { "+", "-", "*", "÷", "(", ")" }, 79 { "+", "-", "*", "÷", "(", ")" } }; 80 int first[][] = { { 1, 1, 2, 2, 2, 0 }, { 1, 1, 2, 2, 2, 0 }, 81 { 1, 1, 1, 1, 2, 0 }, { 1, 1, 1, 1, 2, 0 }, 82 { 2, 2, 2, 2, 2, 0 }, { 2, 2, 2, 2, 2, 2 } }; 83 for (int i = 0; i < 6; i++) { 84 if (ysfin.equalsIgnoreCase(a_ysf[0][i])) 85 m = i; 86 } 87 for (int i = 0; i < 6; i++) { 88 if (ysfout.equalsIgnoreCase(a_ysf[1][i])) 89 n = i; 90 } 91 if (m == -1 && n == -1) 92 return false; 93 else if (m == -1 && n != -1) 94 return false; 95 else if (m != -1 && n == -1) 96 return true; 97 else if (first[m][n] == 1) { 98 return true; 99 } else 100 return false; 101 } 102 103 }
3、将表达式中所有数值转为分数形式：
1 package Calculation; 2 3 import java.util.Stack; 4 5 public class CaoZuoShu_handle { 6 7 8 //该类将后续表达式stack转化为有分子分母的后续表达式 9 //存于Calcul_Expression对象的calculatorStack中 10 11 Stack<Calcul_Expression> posfixStack; 12 13 public CaoZuoShu_handle(Stack<String> stack) { 14 Stack<Calcul_Expression> stack1 = new Stack<>();//中间栈 15 Stack<Calcul_Expression> stack2 = new Stack<>();//中间栈 16 while(!stack.isEmpty()){ 17 String string = stack.pop(); 18 //运算符直接进栈 19 if(string.equals("+")||string.equals("-")||string.equals("*")||string.equals("÷")){ 20 Calcul_Expression calcul_exp = new Calcul_Expression(true,string); 21 stack1.push(calcul_exp); 22 } 23 else if(!string.contains("/")){ 24 string = string + "/1"; 25 Calcul_Expression node = new Calcul_Expression(false,string); 26 stack1.push(node); 27 } 28 else { 29 Calcul_Expression calculator = new Calcul_Expression(false,string); 30 stack1.push(calculator); 31 } 32 } 33 for(Calcul_Expression c:stack1){ 34 stack2.push(c); 35 } 36 this.posfixStack = stack2; 37 38 } 39 40 41 }
4、表达式计算
1 package Calculation; 2 3 import java.util.ArrayList; 4 import java.util.HashMap; 5 import java.util.Stack; 6 7 public class Calcul_Expression { //计算表达式 8 9 10 11 private static final int String = 0; 12 Integer fenzi;//分子 13 Integer fenmu;//分母 14 boolean isysf; 15 String ysf; 16 Calcul_Expression lChild; 17 Calcul_Expression rChild; 18 19 20 //运算符构造方法 21 public Calcul_Expression(boolean isysf,Integer num,Integer den) { 22 this.isysf = isysf; 23 this.fenmu = den; 24 this.fenzi = num; 25 26 } 27 28 public Calcul_Expression(boolean isysf,String stackElement) { 29 if(isysf == true){//为运算符 30 this.isysf = true; 31 this.ysf = stackElement; 32 } 33 else if (isysf == false && stackElement.contains("'")){//为带分数 34 String[] split1 = stackElement.split("'"); 35 String[] split2 = split1[1].split("\\/"); 36 this.fenzi = Integer.parseInt(split1[0])*Integer.parseInt(split2[1]) 37 + Integer.parseInt(split2[0]); 38 this.fenmu = Integer.parseInt(split2[1]); 39 } 40 else if(isysf == false && (!stackElement.contains("'"))){//为分数 41 String[] s = stackElement.split("\\/"); 42 this.fenzi = Integer.parseInt(s[0]); 43 this.fenmu = Integer.parseInt(s[1]); 44 } 45 } 46 47 48 49 public Calcul_Expression() { 50 } 51 52 //根据后缀表达式（分子分母形式）计算 53 //返回运算结果存于stack2中 54 public Stack<Calcul_Expression> calculate(Stack<Calcul_Expression> stackOld){ 55 Stack<Calcul_Expression> stack=(Stack<Calcul_Expression>) stackOld.clone(); 56 Stack<Calcul_Expression> stack2 = new Stack<>(); 57 Calcul_Expression calculator; 58 while(!stack.isEmpty()){ 59 if(!(calculator = stack.pop()).isysf){//操作数直接入栈 60 stack2.push(calculator); 61 } 62 else if(calculator.isysf){//若为运算符 63 64 //每次去除栈顶两个元素 65 Calcul_Expression calculator1 = stack2.pop(); 66 Calcul_Expression calculator2 = stack2.pop(); 67 68 switch (calculator.ysf) { 69 case "+": 70 stack2.push(calculator.add(calculator2, calculator1)); 71 break; 72 73 case "-": 74 Calcul_Expression res=calculator.sub(calculator2, calculator1); 75 if(res.fenzi>0){ 76 stack2.push(res); 77 }else{ 78 res.ysf="#"; 79 stack2.push(res); 80 return stack2; 81 } 82 stack2.push(calculator.sub(calculator2, calculator1)); 83 break; 84 85 case "*": 86 stack2.push(calculator.mul(calculator2, calculator1)); 87 break; 88 89 case "÷": 90 stack2.push(calculator.div(calculator2, calculator1)); 91 break; 92 93 default: 94 break; 95 } 96 97 } 98 } 99 return stack2; 100 } 101 102 //加法 103 public Calcul_Expression add(Calcul_Expression calculator1,Calcul_Expression calculator2) { 104 Integer num = calculator1.fenzi*calculator2.fenmu + 105 calculator2.fenzi*calculator1.fenmu; 106 Integer den = calculator1.fenmu*calculator2.fenmu; 107 int g = gcd(num, den); 108 Calcul_Expression calculator = new Calcul_Expression(false, num/g, den/g); 109 return calculator; 110 } 111 112 //减法 113 public Calcul_Expression sub(Calcul_Expression calculator1,Calcul_Expression calculator2) { 114 Integer num = calculator1.fenzi*calculator2.fenmu - 115 calculator2.fenzi*calculator1.fenmu; 116 Integer den = calculator1.fenmu*calculator2.fenmu; 117 int g = gcd(num, den); 118 Calcul_Expression calculator = new Calcul_Expression(false, num/g, den/g); 119 return calculator; 120 } 121 122 //乘法 123 public Calcul_Expression mul(Calcul_Expression calculator1,Calcul_Expression calculator2) { 124 Integer num = calculator1.fenzi*calculator2.fenzi; 125 Integer den = calculator1.fenmu*calculator2.fenmu; 126 int g = gcd(num, den); 127 Calcul_Expression calculator = new Calcul_Expression(false, num/g, den/g); 128 return calculator; 129 } 130 131 //除法 132 public Calcul_Expression div(Calcul_Expression calculator1,Calcul_Expression calculator2) { 133 Integer num = calculator1.fenzi*calculator2.fenmu; 134 Integer den = calculator1.fenmu*calculator2.fenzi; 135 int g = gcd(num, den); 136 Calcul_Expression calculator = new Calcul_Expression(false, num/g, den/g); 137 return calculator; 138 } 139 140 //最大公约数 141 public int gcd(int a, int b){ 142 int m = Math.max(Math.abs(a), Math.abs(b)); 143 int n = Math.min(Math.abs(a), Math.abs(b)); 144 int r; 145 while(n!=0){ 146 r = m % n; 147 m = n; 148 n = r; 149 } 150 return m; 151 } 152 153 //比较两个分数数大小 154 /** 155 * 156 * @return f1 > f2 返回 2 157 * f1 = f2返回1 158 * f1 < f2返回-1 159 * 其他 返回0 160 */ 161 public int compareFraction(Calcul_Expression f1,Calcul_Expression f2) { 162 Calcul_Expression node = new Calcul_Expression(); 163 164 if (f1.isysf||f2.isysf) { 165 System.out.println("请输入数字进行比较！"); 166 return 0; 167 } 168 Calcul_Expression compare = node.sub(f1, f2);//f1 - f2 结果为Calcul_Expression类型 169 int result = compare.fenzi/compare.fenmu;//f1 - f2的结果 170 if (result == 0) { 171 return 1; 172 } 173 else if (result > 0) { 174 return 2; 175 } 176 else if (result < 0) { 177 return -1; 178 } 179 180 return 0; 181 } 182 183 /** 184 * 185 * @param o1 186 * @param o2 187 * @return o1 > o2 return 2 188 * o1 = o2 return 1 189 * o1 < o2 return -1 190 * 其他 return 0 191 */ 192 public int compareysf(Calcul_Expression o1,Calcul_Expression o2) { 193 if (!o1.isysf||!o2.isysf) { 194 System.out.println("请输入正确运算符！"); 195 return 0; 196 } 197 HashMap<String, Integer> priMap = new HashMap<>(); 198 priMap.put("+", 0); 199 priMap.put("-", 0); 200 priMap.put("*", 1); 201 priMap.put("÷", 1); 202 203 if (priMap.get(o1.ysf) > priMap.get(o2.ysf)) { 204 //o1 高于 o2 205 return 2; 206 } 207 else if (priMap.get(o1.ysf) == priMap.get(o2.ysf)) { 208 //o1 低于o2 209 return 1; 210 } 211 else if (priMap.get(o1.ysf) < priMap.get(o2.ysf)) { 212 //o1等于o2 213 return 1; 214 } 215 return 0; 216 } 217 218 //假分数转带分数输出 219 public ArrayList<String> imTomix(ArrayList<Calcul_Expression> answerList) { 220 ArrayList<String> arrayList = new ArrayList<>(); 221 for (int i = 0; i < answerList.size(); i++) { 222 if (answerList.get(i).isysf) { 223 System.out.println("这个结果算错了！"); 224 } 225 else if (answerList.get(i).fenmu == 1){//分母为1,分数= 分子的值 226 arrayList.add(answerList.get(i).fenzi + ""); 227 } 228 else if ((answerList.get(i).fenzi == 0) ||(answerList.get(i).fenzi == 0)) {//若分子为0，则分数为0 229 arrayList.add(answerList.get(i).fenzi + ""); 230 } 231 else if (answerList.get(i).fenzi == answerList.get(i).fenmu) {//分子等于分母，answer=1 232 arrayList.add(1+""); 233 } 234 else if (answerList.get(i).fenzi%answerList.get(i).fenmu == 0) {//分子能整除分母 235 arrayList.add(answerList.get(i).fenzi/answerList.get(i).fenmu + ""); 236 } 237 else if((answerList.get(i).fenmu!=0)&&answerList.get(i).fenzi/answerList.get(i).fenmu> 1) {//假分数，转带分数 238 arrayList.add(answerList.get(i).fenzi/answerList.get(i).fenmu + "'" 239 + answerList.get(i).fenzi%answerList.get(i).fenmu + "/" + answerList.get(i).fenmu); 240 } 241 else { 242 arrayList.add(answerList.get(i).fenzi + "/" + answerList.get(i).fenmu + ""); 243 } 244 } 245 return arrayList; 246 } 247 248 249 250 251 }
5、检查重复
1 package Calculation; 2 3 import java.util.ArrayList; 4 import java.util.Stack; 5 6 /** 7 * 构造方法：生成查重表达式 8 * @author LHY 9 * 10 */ 11 public class Repeat { 12 /** 13 * @param profixStack 后缀表达式栈 14 */ 15 public Stack<Calcul_Expression> checkRepeat(Stack<Calcul_Expression> profixStack) { 16 // TODO Auto-generated constructor stub 17 Stack<Calcul_Expression> numberStack = new Stack<>(); //构造一个中间栈，存放数字 18 Stack<Calcul_Expression> checkStack = new Stack<>(); //存放查重表达式栈 19 20 // System.out.println(1); 21 Calcul_Expression bookNode = new Calcul_Expression(true, 0,0); 22 // System.out.println(2); 23 Calcul_Expression node1 = new Calcul_Expression(); 24 Calcul_Expression node2 = new Calcul_Expression(); 25 while(!profixStack.isEmpty()){//扫描后缀表达式栈直至其为空 26 Calcul_Expression proStack_top = profixStack.pop();//开始扫描第一个 27 if (!proStack_top.isysf&&!(proStack_top.fenzi==0&&proStack_top.fenmu==0)) {//若后缀表达式栈顶元素为数字。若非#则进numberStack 28 numberStack.push(proStack_top); 29 // System.out.println(proStack_top); 30 } 31 // else if (proStack_top.isOperator&&proStack_top.numerator==0&&proStack_top.denominator==0) { 32 // numberStack.pop(); 33 // } 34 else if (proStack_top.isysf) {//后缀表达式栈顶为运算符,则进checkStack,再pop两个数字,并把#压进数字 35 checkStack.push(proStack_top); 36 if (numberStack.size() > 1) { 37 if (!(node1=numberStack.pop()).isysf&&!(node1.fenzi==0)&&!(node1.fenmu==0)) {//非# 38 checkStack.push(node1); 39 } 40 if (!(node2=numberStack.pop()).isysf&&!(node2.fenzi==0)&&!(node2.fenmu==0)) { 41 checkStack.push(node2); 42 } 43 } 44 numberStack.push(bookNode); 45 } 46 47 }//end while 48 System.out.println("size"+checkStack.size()); 49 for(Calcul_Expression node:checkStack){ 50 if (node.isysf) { 51 System.out.print(node.ysf + " "); 52 }else if(!node.isysf){ 53 System.out.print(node.fenzi + "/" + node.fenmu + " "); 54 } 55 } 56 return checkStack; 57 58 } 59 60 public boolean IsRepeat(Stack<Calcul_Expression> exp1,Stack<Calcul_Expression> exp2){ 61 Repeat repeat=new Repeat(); 62 //转成查重表达式 63 ArrayList<Calcul_Expression> temp=new ArrayList<Calcul_Expression>();//中间存放栈1 64 Calcul_Expression tempNode=new Calcul_Expression();//中间交换结点 65 Stack<Calcul_Expression> checkRepeat1=repeat.checkRepeat(exp1); 66 Stack<Calcul_Expression> checkRepeat2=repeat.checkRepeat(exp2); 67 Stack<Calcul_Expression> newStack=new Stack<Calcul_Expression>();//交换后的新栈 68 int lengthRe1=checkRepeat1.size(); 69 int lengthRe2=checkRepeat2.size(); 70 System.out.println(1); 71 if(lengthRe1!=lengthRe2) return false;//若长度不相等，则表达式一定不同 72 System.out.println(2); 73 for(Calcul_Expression n:checkRepeat1){ 74 temp.add(n); 75 } 76 if (this.isEqual(checkRepeat1, checkRepeat2)) {//完全一样则返回true 77 return true; 78 } 79 80 if(temp.get(0).ysf.equals("+")||temp.get(0).ysf.equals("*")){//只有加或乘的情况才可能出现 交换左右操作数当做重复的表达式 81 tempNode=temp.get(1); 82 temp.set(1, temp.get(2)); 83 temp.set(2, tempNode); 84 } 85 for(Calcul_Expression p:temp){ 86 newStack.push(p); 87 } 88 if(this.isEqual(newStack, checkRepeat2)) return true;//若交换后也相等则重复 89 System.out.println(3); 90 return false; 91 } 92 93 public boolean isEqual(Stack<Calcul_Expression> stack1,Stack<Calcul_Expression> stack2) { 94 Stack<Calcul_Expression> s1 = new Stack<>(); 95 Stack<Calcul_Expression> s2 = new Stack<>(); 96 97 Calcul_Expression s1_top; 98 Calcul_Expression s2_top; 99 for(Calcul_Expression node1:stack1){ 100 s1.push(node1); 101 } 102 for(Calcul_Expression node2:stack2){ 103 s2.push(node2); 104 } 105 106 while (!s1.isEmpty()&&!s2.isEmpty()) { 107 s1_top = s1.pop(); 108 s2_top = s2.pop(); 109 if (s1_top.isysf) {//若s1栈顶为运算符 110 if (s2_top.isysf&&(!s2_top.ysf.equals(s1_top.ysf))) {//s2都为运算符但s1不等于s2 111 return false; 112 } 113 else if (!s2_top.isysf) {//s1为运算符，s2非运算符 114 return false; 115 } 116 } 117 else if (!s1_top.isysf) {//若s1操作数 118 if (s2_top.isysf) {//s2为运算符 119 return false; 120 } 121 else if (!s2_top.isysf&&(s2_top.compareFraction(s1_top, s2_top)!=1)) {//s2为操作数但不等于s1 122 return false; 123 } 124 } 125 126 } 127 return true; 128 } 129 }
6、满足非负及非重复条件生成表达式
int count=0; ArrayList<String> finalExp=new ArrayList<>();//最终所有表达式 ArrayList<Calcul_Expression> finalRes=new ArrayList<>();//最终所有结果（假分数） ArrayList<String> realRes =new ArrayList<>();//最终所有结果（真分数） ArrayList<Stack<Calcul_Expression>> checkArray=new ArrayList<>();//查重存放数组 Repeat repeat=new Repeat(); do { boolean flag=false; Stack<String> ac=new Stack<String>(); ac=After_Expression.toAfter_Expression(Ran_Expression.creatAc(range));//没带分母的后缀表达式 CaoZuoShu_handle handle=new CaoZuoShu_handle(ac);//带分母的后缀表达式 Calcul_Expression node=new Calcul_Expression(); Stack<Calcul_Expression> stack=new Stack<Calcul_Expression>(); stack=node.calculate(handle.posfixStack);//计算结果 if(stack.peek().ysf!="#"&&count==0){//非负，第一个表达式 checkArray.add(handle.posfixStack); finalExp.add(Ran_Expression.exp_str); finalRes.add(stack.peek()); count++; } if(stack.peek().ysf!="#"&&count>0){//非负，第二个表达式开始 for(Stack<Calcul_Expression> p:checkArray){ if(repeat.isEqual(p, handle.posfixStack)){ flag=true; } } if(!flag){ checkArray.add(handle.posfixStack); finalExp.add(Ran_Expression.exp_str); finalRes.add(stack.peek()); count++; } } } while (count!=number); Calcul_Expression transNode=new Calcul_Expression(); realRes=transNode.imTomix(finalRes); for (int i = 0; i < finalExp.size(); i++) { System.out.println("第"+i+"题："+finalExp.get(i)); } for (int i = 0; i < realRes.size(); i++) { System.out.println("第"+i+"题答案："+realRes.get(i)); } System.out.println("答案真正长度"+finalRes.size());
7、文件读取
package Calculation; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.Reader; import java.util.ArrayList; import javax.imageio.spi.RegisterableService; public class FileRW { /** * 将题目和答案写出在txt文件中 * @param expList 题目集合 * @param answerList 答案集合 * @return true 成功 * false 失败 */ public boolean fileWrite(ArrayList<String> expList,ArrayList<Calcul_Expression> answerList) { ArrayList<String> outList = new ArrayList<>(); if (expList.size()!=answerList.size()) { System.out.println("答案与题目数目不匹配！"); return false; } for (int i = 0; i < expList.size(); i++) { System.out.println(); outList.add(expList.get(i) + " = " +answerList.get(i).fenzi + "/"+ answerList.get(i).fenmu); } //开始写入文件 try { BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt")); for(String s:outList){ bw.write(s); bw.newLine(); bw.flush(); } bw.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return true; } /** * 把题目写出到文件 * @param expList * @return */ public File writeQ(ArrayList<String> expList) { int count = 1; File file = new File("Question.txt"); try { FileWriter fWriter = new FileWriter(file); BufferedWriter bw = new BufferedWriter(fWriter); for(String s:expList){ bw.write( count++ + "." +s); bw.newLine(); bw.flush(); } bw.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return file; } /** * 把答案写出到文件 * @param answerList * @return * @throws IOException */ public File writeA(ArrayList<String> answerList) throws IOException { int count = 1; File file = new File("Answer.txt"); FileWriter fWriter = new FileWriter(file); try { BufferedWriter bw = new BufferedWriter(fWriter); for(String s:answerList){ bw.write( count++ + "." +s); bw.newLine(); bw.flush(); } bw.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return file; } /** * * @param answerFile 待检测文件 * @param answerList 正确答案文件 * @return */ public File checkAnswer(File answerFile,File answerList) { try { BufferedReader rightReader = new BufferedReader(new FileReader(answerList)); BufferedReader anserReader = new BufferedReader(new FileReader(answerFile)); String rightString = null; String answerString = null; int right = 0; int wrong = 0; int line = 1; String Rnumber=""; String Wnumber=""; //比较对错 while((rightString=rightReader.readLine())!=null&&(answerString=anserReader.readLine())!=null){ if(rightString.equals(answerString)){ right ++; if (Rnumber.equals("")) { Rnumber = Rnumber +line; } else{ Rnumber = Rnumber + ","+line; } } else { System.out.println(rightString); System.out.println(answerString); wrong++; if (Wnumber.equals("")) { Wnumber = Wnumber +line; }else{ Wnumber = Wnumber + "," +line; } } line++; } //写入到answerfile中 BufferedWriter bw = new BufferedWriter(new FileWriter(answerFile, true)); bw.newLine(); bw.write("right: "+ right + " " + "("+ Rnumber +")" + ";"); bw.newLine(); bw.write("wrong: "+ wrong + " " + "("+ Wnumber + ")"+ ";"); bw.flush(); bw.close(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } return answerFile; } }
五、测试截图
代码覆盖率：
六、PSP时间统计
|
PSP2.1 |
Personal Software Process Stages |
预估耗时（分钟） |
实际耗时（分钟） |
|
Planning |
计划 |
45 |
47 |
|
· Estimate |
· 估计这个任务需要多少时间 |
45 |
47 |
|
Development |
开发 |
1405 |
1492 |
|
· Analysis |
· 需求分析 (包括学习新技术) |
80 |
95 |
|
· Design Spec |
· 生成设计文档 |
40 |
36 |
|
· Design Review |
· 设计复审 (和同事审核设计文档) |
45 |
55 |
|
· Coding Standard |
· 代码规范 (为目前的开发制定合适的规范) |
35 |
30 |
|
· Design |
· 具体设计 |
120 |
107 |
|
· Coding |
· 具体编码 |
960 |
1050 |
|
· Code Review |
· 代码复审 |
50 |
35 |
|
· Test |
· 测试（自我测试，修改代码，提交修改） |
75 |
84 |
|
Reporting |
报告 |
180 |
235 |
|
· Test Report |
· 测试报告 |
120 |
180 |
|
· Size Measurement |
· 计算工作量 |
20 |
20 |
|
· Postmortem & Process Improvement Plan |
· 事后总结, 并提出过程改进计划 |
40 |
35 |
|
合计 |
|
1630 |
1774 |
七、项目总结
这次结对编程项目相比上次的个人项目，整体的完成过程要更为复杂一些，也更加耗时间。做个人项目的时候，可以自己按照自己整体的代码构架和实现思路去走，在类的创建和实现上，也比较自由。而本次结对编程，就要求我们在团队协作这一块上一定要做得好，两个人一起实现同一个项目并不是一件简单的事情。我们在一开始对项目设计的讨论中，由于没有很明确地达成一致的思路，可以说只是商定了一个大概的框架，所以真正在分工实现项目的过程中，难免出现了一些问题，在最后联结双方的项目工程时发现无法完全契合双方的各种实现类。于是，在经过第二轮的讨论交流和实践修改后，才得以完成本次结对编程项目，这让我们都意识到小组交流和相互更新进度这些合作事宜的重要性。这次项目也让我们两个人从中学到了很多，明确了彼此的一些知识盲区，相信有了结对编程的经验后，在后续的团队编程项目中我们会做得更好。
