结对编程项目
结对编程
要求
软工作业 | 结对编程:实现一个自动生成小学四则运算题目的命令行程序 |
---|---|
作业要求 | 结对项目要求 |
作业目标 | 一个自动生成小学四则运算题目的命令行程序,附带判断对错和题目查重功能 |
合作者
李纪然3218005441
陈雪莹3218005439
GitHub地址
李纪然:https://github.com/CIELIEL/3218005441
陈雪莹:https://github.com/deerc123/jiedui
PSP表格
PSP2.1 | Personal Software Process Stages | 预估耗时(分钟) | 实际耗时(分钟) |
---|---|---|---|
Planning | 计划 | 30 | 30 |
·Estimate | ·估计这个任务需要多少时间 | 1440 | 1680 |
Development | 开发 | 60 | 30 |
·Analysis | ·需求分析(包括学习新技术) | 300 | 360 |
·Design Spec | ·生成设计文档 | 60 | 90 |
·Design Review | ·设计复审(和同事审核设计文档) | 30 | 30 |
·Coding Standard | ·代码规范(为目前的开发制定合适的规范) | 30 | 30 |
·Design | ·具体设计 | 60 | 50 |
·Coding | ·具体编码 | 600 | 670 |
·Code Review | ·代码复审 | 180 | 300 |
· Test | ·测试(自我测试,修改代码,提交修改) | 180 | 240 |
Reporting | 报告 | 120 | 150 |
·Test Report | ·测试报告 | 30 | 20 |
·Size Measurement | ·计算工作量 | 10 | 10 |
·Postmortem&Process Improvement Plan | ·事后总结,并提出过程改进计划 | 10 | 10 |
合计 | 1700 | 2020 |
效能分析
改进思路
改进程序耗费时间:大约8个小时
四则运算:在getresult()方法中:当碰到符号为减法时,我们通过判断左右结点的大小来决定是否调换左右结点的位置,这样就能避免生成负数的情况,当碰到符号为除法时,判断除数是否为0,为0则重新随机符号(除了/)
查重:利用DuplicateCheck类中的CompareStringByChar(String strA,String strB)方法判断两个String如果满足条件两个字符串所含元素相同、所含每个元素数量相等、字符串长度相等,就返回ture。这样可以比直接比较字符串更准确判断出题目是否相等
性能分析图
CPU占比
时间占比
空间占比
由图可得,程序中消耗最大的函数为BinaryTree类中的createBTree方法
设计实现过程
代码的类
代码关系
(Test类)主函数:输入题目数量参数和选择操作代表值—(调用)—>(CreatSubjects类)输入生成运算符数量参数,输出运行后的结果,判断答题对错
(CreatSubjects类)—(调用)—>(BinaryTree类)createBTree() 方法:生成二叉树;CalAndVal()方法:得出运行后的结果并打印到Answer文档;toString()方法:打印中序遍历二叉树的结果到Exan文档
(BinaryTree类)—(调用)—(1)(Ran类)getOperator()方法:随机生成有孩子结点的符号;getnumber()方法:获取叶子结点的数值;getChildPlace()方法:根据运算符的个数随机产生子节点的位置(2)(TreeNode类)getresult()方法:获取四则运算后的结果;toString()方法:根据去括号法则去掉多余的括号并获取去括号后的运算式
(TreeNode类)—(调用)—(1)(FractionStack类)setNumerator()方法:设置分子;setDenominator()方法:设置分母;getRealRes()方法:将分数运算后的结果转化成真分数形式(2)(FractionCal类)fracAdd()方法:进行分数加法运算;fracSub()方法:进行分数减法运算;fracMul()方法:进行分数乘法运算;fractDiv()方法:进行分数除法运算
(FractionCal类)—(调用)—(FractionStack类):分装一个分数供运算
(BinaryList类):存储二叉树以供查重
(DuplicateCheck类):查重算法
代码说明
核心代码展示
生成二叉树
public void createBTree() {
TreeNode lchild, rchild, lnode, rnode;
String check;
do {
if (num == 1) {
lchild = new TreeNode(String.valueOf(Ran.getNumber(100)), null, null);
rchild = new TreeNode(String.valueOf(Ran.getNumber(100)), null, null);
root = new TreeNode(String.valueOf(Ran.getOperator()), lchild, rchild);
} else {
int num1 = 0;
int n = getDeep() - 3;
boolean[] place = Ran.getChildPlace(num);
char rootString = Ran.getOperator();
root = new TreeNode(String.valueOf(rootString), null, null);
opeList.add(root);
//System.out.println(root.getStr());
for (int i = 0; i < n; i++) {
for (int j = 0; j < (int) Math.pow(2, i); j++, num1++) {
lchild = new TreeNode(String.valueOf(Ran.getOperator()), null, null);
rchild = new TreeNode(String.valueOf(Ran.getOperator()), null, null);
opeList.get(j + num1).setChild(lchild, rchild);
opeList.add(lchild);
opeList.add(rchild);
}
}
for (int i = 0; i < place.length; i++) {
if (place[i]) {
int a1 = Ran.getNumber(10);
lnode = new TreeNode(String.valueOf(Ran.getNumber(100)), null, null);
rnode = new TreeNode(String.valueOf(Ran.getNumber(100)), null, null);
if (i % 2 == 0) {
lchild = new TreeNode(String.valueOf(Ran.getOperator()), lnode, rnode);
opeList.add(lchild);
opeList.get(num1).setLchild(lchild);
} else {
rchild = new TreeNode(String.valueOf(Ran.getOperator()), lnode, rnode);
opeList.add(rchild);
opeList.get(num1).setRchild(rchild);
}
} else {
if (i % 2 == 0) {
lchild = new TreeNode(String.valueOf(Ran.getNumber(100)), null, null);
opeList.get(num1).setLchild(lchild);
} else {
rchild = new TreeNode(String.valueOf(Ran.getNumber(100)), null, null);
opeList.get(num1).setRchild(rchild);
}
}
num1 = num1 + i % 2;
}
//BinaryList binaryList=new BinaryList();
// String check=deleteCharString0(root.toString(),')','(');
//binaryList.saveBinary(deleteCharString0(root.toString(),')','('));
//BinaryList args=new BinaryList();
//args.args(root);
//RootSave rootSave=new RootSave();
//rootSave.saveRoot(rootString);
//binaryTreesList.add(this);
}
//check=deleteCharString0(root.toString(),')','(');
}while (DuplicateCheck.checkDuplicate(root.toString(),BinaryList.saveList)||root.getLchild()==null||root.getRchild()==null);
BinaryList.saveBinary(deleteCharString0(root.toString(),')','('));
四则运算
public String getResult(ArrayList arrayList) {
if (hasChild()) {
switch (str) {
case "+":
//左右子树如果有孩子,说明左右子树是一个表达式,而不是数字节点。
if (getRchild().hasChild() || getLchild().hasChild()) {
//判断左右邻括号的运算符是否为'/',是的话进入分数运算
if (getRchild().str.equals("/") || getLchild().str.equals("/")) {
if (getRchild().str.equals("/") && getLchild().str.equals("/")) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getLchild().getRchild().getResult(arrayList)));
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getLchild().getResult(arrayList)));
f2.setDenominator(Integer.parseInt(getRchild().getRchild().getResult(arrayList)));
FractionCal f = new FractionCal();
return f.fracAdd(f1, f2).getRealRes();
}
if ((getLchild().str.equals("+") || getLchild().str.equals("-") || getLchild().str.equals("*") || !(getLchild().hasChild())) && getRchild().str.equals("/")) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getResult(arrayList)));
f1.setDenominator(1);
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getLchild().getResult(arrayList)));
f2.setDenominator(Integer.parseInt(getRchild().getRchild().getResult(arrayList)));
FractionCal f = new FractionCal();
return f.fracAdd(f1, f2).getRealRes();
}
if (getLchild().str.equals("/") && (getRchild().str.equals("+") || getRchild().str.equals("-") || getRchild().str.equals("*") || !(getRchild().hasChild()))) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getLchild().getRchild().getResult(arrayList)));
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getResult(arrayList)));
f2.setDenominator(1);
FractionCal f = new FractionCal();
return f.fracAdd(f1, f2).getRealRes();
}
}
return String.valueOf(Integer.parseInt(getLchild().getResult(arrayList)) + Integer.parseInt(getRchild().getResult(arrayList)));
}
return String.valueOf(Integer.parseInt(getLchild().getResult(arrayList)) + Integer.parseInt(getRchild().getResult(arrayList)));
case "-":
//左右子树如果有孩子,说明左右子树是一个表达式,而不是数字节点。
if (getRchild().hasChild() || getLchild().hasChild()) {
//判断左右邻括号的运算符是否为'/'
if (getRchild().str.equals("/") || getLchild().str.equals("/")) {
if (getRchild().str.equals("/") && getLchild().str.equals("/")) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getLchild().getRchild().getResult(arrayList)));
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getLchild().getResult(arrayList)));
f2.setDenominator(Integer.parseInt(getRchild().getRchild().getResult(arrayList)));
FractionCal f = new FractionCal();
if ((f.fracSub(f1, f2).getRealRes()).charAt(0) == '-') {
TreeNode treeNode = new TreeNode();
treeNode = getLchild();
this.lchild = this.rchild;
this.rchild = treeNode;
FractionCal f5 = new FractionCal();
return f5.fracSub(f2, f1).getRealRes();
}
return f.fracSub(f1, f2).getRealRes();
}
if (getLchild().str.equals("+") || getLchild().str.equals("-") || getLchild().str.equals("*") || !(getLchild().hasChild())) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getResult(arrayList)));
f1.setDenominator(1);
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getLchild().getResult(arrayList)));
f2.setDenominator(Integer.parseInt(getRchild().getRchild().getResult(arrayList)));
FractionCal f = new FractionCal();
if ((f.fracSub(f1, f2).getRealRes()).charAt(0) == '-') {
TreeNode treeNode = new TreeNode();
treeNode = getLchild();
this.lchild = this.rchild;
this.rchild = treeNode;
FractionCal f5 = new FractionCal();
return f5.fracSub(f2, f1).getRealRes();
}
return f.fracSub(f1, f2).getRealRes();
}
if (getLchild().str.equals("/") && (getRchild().str.equals("+") || getRchild().str.equals("-") || getRchild().str.equals("*") || !(getRchild().hasChild()))) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getLchild().getRchild().getResult(arrayList)));
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getResult(arrayList)));
f2.setDenominator(1);
FractionCal f = new FractionCal();
if ((f.fracSub(f1, f2).getRealRes()).charAt(0) == '-') {
TreeNode treeNode = new TreeNode();
treeNode = getLchild();
this.lchild = this.rchild;
this.rchild = treeNode;
FractionCal f5 = new FractionCal();
return f5.fracSub(f2, f1).getRealRes();
}
return f.fracSub(f1, f2).getRealRes();
}
}
if (Integer.parseInt(getLchild().getResult(arrayList)) > Integer.parseInt(getRchild().getResult(arrayList)) || Integer.parseInt(getLchild().getResult(arrayList)) == Integer.parseInt(getRchild().getResult(arrayList))) {
return String.valueOf(Integer.parseInt(getLchild().getResult(arrayList)) - Integer.parseInt(getRchild().getResult(arrayList)));
}
if (Integer.parseInt(getLchild().getResult(arrayList)) < Integer.parseInt(getRchild().getResult(arrayList))) {
TreeNode treeNode = new TreeNode();
treeNode = getLchild();
this.lchild = this.rchild;
this.rchild = treeNode;
return String.valueOf(Integer.parseInt(getLchild().getResult(arrayList)) - Integer.parseInt(getRchild().getResult(arrayList)));
}
return this.getResult(arrayList);
}
else {
if (Integer.parseInt(getLchild().str) > Integer.parseInt(getRchild().str) || Integer.parseInt(getLchild().str) == Integer.parseInt(getRchild().str)) {
return String.valueOf(Integer.parseInt(getLchild().str) - Integer.parseInt(getRchild().str));
}
if (Integer.parseInt(getLchild().getResult(arrayList)) < Integer.parseInt(getRchild().getResult(arrayList))) {
TreeNode treeNode = new TreeNode();
treeNode = getLchild();
this.lchild = this.rchild;
this.rchild = treeNode;
return String.valueOf(Integer.parseInt(getLchild().str) - Integer.parseInt(getRchild().str));
}
// return this.getResult(arrayList);
}
case "*":
//左右子树如果有孩子,说明左右子树是一个表达式,而不是数字节点。
if (getRchild().hasChild() || getLchild().hasChild()) {
//判断左右邻括号的运算符是否为'/'
if (getRchild().str.equals("/") || getLchild().str.equals("/")) {
if (getRchild().str.equals("/") && getLchild().str.equals("/")) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getLchild().getRchild().getResult(arrayList)));
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getLchild().getResult(arrayList)));
f2.setDenominator(Integer.parseInt(getRchild().getRchild().getResult(arrayList)));
FractionCal f = new FractionCal();
return f.fracMul(f1, f2).getRealRes();
} else if (getLchild().str.equals("+") || getLchild().str.equals("-") || getLchild().str.equals("*") || !(getLchild().hasChild())) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getResult(arrayList)));
f1.setDenominator(1);
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getLchild().getResult(arrayList)));
f2.setDenominator(Integer.parseInt(getRchild().getRchild().getResult(arrayList)));
FractionCal f = new FractionCal();
return f.fracMul(f1, f2).getRealRes();
}
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getLchild().getRchild().getResult(arrayList)));
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getResult(arrayList)));
f2.setDenominator(1);
FractionCal f = new FractionCal();
return f.fracMul(f1, f2).getRealRes();
}
return String.valueOf(Integer.parseInt(getLchild().getResult(arrayList)) * Integer.parseInt(getRchild().getResult(arrayList)));
}
return String.valueOf(Integer.parseInt(getLchild().getResult(arrayList)) * Integer.parseInt(getRchild().getResult(arrayList)));
/**
* 获取每个节点的运算结果,并检验除法
* 1)除数为0
* 2)不能整除
* 出现以上两种情况的话将该运算符转换成其他三种运算符
*
* @return result
*/
case "/":
if (getRchild().getResult(arrayList).equals("0")||getRchild().getResult(arrayList).equals("0")) {
while (str.equals("/")) {
str = String.valueOf(Ran.getOperator());
System.out.println(str);
}
return this.getResult(arrayList);
}
//左右子树如果有孩子,说明左右子树是一个表达式,而不是数字节点。
if (getRchild().hasChild() || getLchild().hasChild()) {
//判断左右邻括号的运算符是否为'/'
if (getRchild().str.equals("/") || getLchild().str.equals("/")) {
if (getRchild().str.equals("/") && getLchild().str.equals("/")) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getLchild().getRchild().getResult(arrayList)));
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getLchild().getResult(arrayList)));
f2.setDenominator(Integer.parseInt(getRchild().getRchild().getResult(arrayList)));
FractionCal f = new FractionCal();
return f.fractDiv(f1, f2).getRealRes();
} else if (getLchild().str.equals("+") || getLchild().str.equals("-") || getLchild().str.equals("*") || !(getLchild().hasChild())) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getResult(arrayList)));
f1.setDenominator(1);
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getLchild().getResult(arrayList)));
f2.setDenominator(Integer.parseInt(getRchild().getRchild().getResult(arrayList)));
FractionCal f = new FractionCal();
return f.fractDiv(f1, f2).getRealRes();
}
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getLchild().getRchild().getResult(arrayList)));
FractionStack f2 = new FractionStack();
f2.setNumerator(Integer.parseInt(getRchild().getResult(arrayList)));
f2.setDenominator(1);
FractionCal f = new FractionCal();
return f.fractDiv(f1, f2).getRealRes();
}
else if (Integer.parseInt(getLchild().getResult(arrayList)) % Integer.parseInt(getRchild().getResult(arrayList)) != 0) {
if (arrayList.indexOf(this) == 0) {
FractionStack f1 = new FractionStack();
f1.setNumerator(Integer.parseInt(getLchild().getResult(arrayList)));
f1.setDenominator(Integer.parseInt(getRchild().getResult(arrayList)));
return f1.getRealRes();
}
}
return String.valueOf(Integer.parseInt(getLchild().getResult(arrayList)) / Integer.parseInt(getRchild().getResult(arrayList)));
}
/* while (str.equals("/")) {
str = String.valueOf(Ran.getOperator());
}*/
//return this.getResult(arrayList);
return String.valueOf(Integer.parseInt(getLchild().getResult(arrayList)) / Integer.parseInt(getRchild().getResult(arrayList)));
}
}
return str;
}
查重算法
public class DuplicateCheck {
private ArrayList<TreeNode> sameRootList = new ArrayList<>();
// public boolean duplicateCheck(Character root, BinaryTree binaryTree) {
// return true;
// }
public static boolean CompareStringByChar(String strA,String strB)
{
boolean IsEqual = true;
char[] arrA = strA.toCharArray();
char[] arrB = strB.toCharArray();
for (int i=0;i<arrA.length;i++)
{
char c=arrA[i];
if (strB.indexOf(c)==-1)
{
IsEqual = false;
}
else
{
if(GetSameCharCount(c,arrA)!=GetSameCharCount(c,arrB))
{
IsEqual = false;
}
}
}
for(int k=0;k<arrB.length;k++)//char charb in arrB
{
char b=arrB[k];
if (strA.indexOf(b)==-1)//!strA.Contains(charb)
{
IsEqual = false;
}
else
{
if (GetSameCharCount(b, arrA) != GetSameCharCount(b, arrB))
{
IsEqual = false;
}
}
}
return IsEqual;
}
//获得某字符在字符串中的数量
private static int GetSameCharCount(Character chara,char[] arrChar)
{
int count = 0;
for(int j=0;j<arrChar.length;j++)
{
if(chara.equals(arrChar[j]))
{
count++;
}
}
return count;
}
public static boolean checkDuplicate(String strA,ArrayList arrayList){
int co=0;
for(int q=0;q<arrayList.size();q++){
if (CompareStringByChar(strA,(String) arrayList.get(0))){
co++;
}
}
return co!=0;
}
}
思路
对于这样一棵二叉树,每个叶子节点都是数字,每个父节点都是符号,然后中序遍历结果就是我们所需要的四则运算,而且每次父节点返回的时候,可以根据符号进行运算式的计算,中序遍历的结果:
*1+2-3*4*
但是如何产生括号呢?
有一个简单的办法就是父节点每次返回的时候带上括号,于是运算式就变成了这样:
*((1+2)-(3*4))*
正确的优先级应该是这样的:*'('、')'>'*'、'/'>'+'、'-'*
通过整理,我们可以得到这样的规律:
假设待去括号的表达式为 (m1 op1 n1) op (m2 op2 n2) 这里m1、n1、m2、m2可能自身就是个表达式,也可能是数字,op、op1、op2为运算符
*1、若op为'/',则 (m2 op2 n2)的括号必须保留;*
*2、若op为'*'或'-',如果op2为'+'或'-',则(m2 op2 n2)的括号必须保留;*
*3、若op为'*'或'/',如果op1为'+'或'-',则(m1 op1 n1)的括号必须保留;*
*4、 除此之外,去掉括号不影响表达式的计算顺序。*
至此,我们就能得到一个比较随机的四则运算式。
测试运行
代码测试
生成10到题目(输入操作参数1)
生成Exam文档
生成Answer文档
在Exam里答题后(输入操作参数2)
答题
批改后
单元测试
分别对creatSubjects类、TreeNode类、DuplicateCheckTest类进行了单元测试,运行成功截图以及代码覆盖率截图如下
creatSubjects类
我们分别测试了生成10000道题目、100道题目,测试均成功。
TreeNode类
DuplicateCheckTest类
项目小结
李纪然项目小结
我发现写代码要理清思路,逻辑清晰,才能更好的用代码实现自己的思路
陈雪莹项目小结
这次结对项目让我深有感触,两个人的合作果然是比一个人单干要效率高!