小学四则运算生成器（Java） 刘少允，梁新男
项目相关要求
- 使用 -n 参数控制生成题目的个数。（实现）
- 使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围。（实现）
- 生成的题目中计算过程不能产生负数。（实现）
- 生成的题目中如果存在形如e1 ÷ e2的子表达式，那么其结果应是真分数。（实现）
- 每道题目中出现的运算符个数不超过3个。（实现）
- 程序一次运行生成的题目不能重复。（实现）
- 在生成题目的同时，计算出所有题目的答案，并存入执行程序的当前目录下的Answers.txt文件。（实现）
- 程序应能支持一万道题目的生成。（实现）
- 程序支持对给定的题目文件和答案文件，判定答案中的对错并进行数量统计。（实现）
效能分析
一开始使用的是ArrayList来存储算式中的数字和符号的，并且整个算式的结构也是一个ArrayList，程序生成10000条算式平均需要4s以上。后来发现在生成优先运算符表中由于过多的修改list的结构导致效率下降，因此后来对于大量用到add和remove操作的地方，把ArrayList换成LinkedList结构，使得生成10000条算式从4s提升到平均1.3s。
使用了链表结构后，生成1000条算式大约需要12ms:
生成10000条算式大约需要1.3s左右
生成100000条算式平均需要1m17s：
设计实现过程
- 四则运算题目生成
在这个程序中运算式的结构主要由链表构成
整体结构如下图所示：
比如3 ×（2+1）的结构：
数字分为三个部分：带分数的整数部分、分子、分母
如果生成的是整数，则只指对分数的整数部分赋值，分子默认为0，分母默认为1；如果生成的是分数，则三个部分均赋值。
运算题目分为两部分：数字和运算符的链表，括号的链表
运算符数目：通过随机函数随机取1-3 - 负数的避免
运用括号链表，按照计算的顺序，将运算优先级高的部分提前，形成优先计算符链表，再逐次计算每个部分，当出现负数时，舍弃这道题目重新生成 - 真分数的显示
计算时为了方便都是用假分数计算，只有在输出时才显示成真分数 - 判断是否重复
通过括号链表按照计算顺序形成优先计算符链表，按照链表顺序依次比较两个数字以及运算符是否完全相同（或可交换），并依次计算结果覆盖，就可判断是否重复
优先运算符链表：依照正常的计算顺序排列的运算符链表，例如：
3 ×（2 + 1）的优先运算符链表： + -> ×，计算第一个+号后：3 × 3
（1 + 2） × 3的优先运算符链表：+ -> ×，计算第一个+号后：3 × 3
代码说明
生成算式的整体结构：
QuestionService questionService = new QuestionService();
RepeatService repeatService = new RepeatService();
List<Question> questionList = new LinkedList<>();
for (int i = 1; i <= questionNumber; i++) {
Question question = questionService.getQuestion(maxRange);
//检查重复题目
\while (question == null || repeatService.isRepeat(questionList, question)) {
question = questionService.getQuestion(maxRange);
}
question.setId(i);
questionList.add(question);
用于生成指定范围的一道题目的class QuestionService：
public class QuestionService {
/**
* 生成指定范围的一道题目
* @param maxRange
* @return 返回一个带运算式和结果的Question
*/
public Question getQuestion(int maxRange) {
Question question = new Question();
Random r = new Random();
int operatorNum = r.nextInt(3) + 1;
List<Operator> operatorList = new LinkedList<>();
List<Char> charList = new LinkedList<>();
for (int i = 0; i < operatorNum; i++) {
//生成运算符
OperatorEnum operatorEnum = OperatorEnum.values()[r.nextInt(4)];
Operator operator = new Operator(i + 1, operatorEnum.getOperator());
operatorList.add(operator);
//生成数字
Number number = createNumber(maxRange, i + 1);
charList.add(number);
charList.add(operator);
}
//生成最后一个数字并加入链表
charList.add(createNumber(maxRange, operatorNum + 1));
//生成括号
List<Parentheses> parenthesesList = new LinkedList<>();
getParenthesesList(1, operatorList.size() + 1, parenthesesList);
//构造运算符优先处理链
List<Operator> buildList = QuestionUtil.buildLink(operatorList, parenthesesList);
//计算结果
List<Char> tempList = new LinkedList<>();
tempList.addAll(charList);
for(int i = 0; i < buildList.size(); i++) {
Operator o = buildList.get(i);
int temp = tempList.indexOf(o);
Number n1 = (Number)tempList.get(temp - 1);
Number n2 = (Number)tempList.get(temp + 1);
Number n = MathUtil.calculate(n1, o, n2);
//返回null表示为减法得出是负数或被除数为0，题目无效返回
if (n == null) {
return null;
}
for (int j = 0; j < 3; j++) {
tempList.remove(temp - 1);
}
tempList.add(temp - 1, n);
if (tempList.size() == 1) {
question.setResult(n.getOutput());
}
}
question.setCharList(charList);
question.setParenthesesList(parenthesesList);
return question;
}
private Number createNumber(int maxRange, int nid) {
Random r = new Random();
NumberTypeEnum numberTypeEnum = NumberTypeEnum.values()[r.nextInt(2)];
if (numberTypeEnum.equals(NumberTypeEnum.NATURAL_NUMBER)) {
return new Number(nid, NumberTypeEnum.NATURAL_NUMBER.getCode(), r.nextInt(maxRange));
} else {
CalculateFraction cf = MathUtil.reduction(r.nextInt(maxRange - 1) + 1, r.nextInt(maxRange - 1) + 1);
Number number = cf.getNumber();
number.setNId(nid);
return number;
}
}
public void getParenthesesList(int startNid, int endNid, List<Parentheses> parenthesesList) {
if (endNid - startNid > 1) {
Random r = new Random();
Parentheses p = null;
for (int i = startNid; i <= endNid - 1; i++) {
if (p != null && i == endNid - 1) {
if (p.getStartNId() == startNid) {
break;
}
p.setEndNId(i + 1);
parenthesesList.add(p);
getParenthesesList(p.getStartNId(), p.getEndNId(), parenthesesList);
break;
}
boolean flag = r.nextBoolean();
if (p != null || !flag) {
if (!flag) {
p = new Parentheses();
p.setStartNId(i);
}
if (flag || r.nextBoolean()) {
p.setEndNId(i + 1);
parenthesesList.add(p);
getParenthesesList(p.getStartNId(), p.getEndNId(), parenthesesList);
p = null;
i = i + 1;
}
}
}
}
}
}
用于验证题目是否重复的class RepeatService：
public class RepeatService {
/**
* 检查题目是否与已有题目重复
* @param questionList
* @param question
* @return
*/
public boolean isRepeat(List<Question> questionList, Question question) {
for (Question origin: questionList) {
//先检查题目答案是否相同再进行下一步
if (origin.getResult().equals(question.getResult())) {
//检查运算符的个数和种类是否相同
if (isOperatorRepeat(QuestionUtil.fatherListToSonList(origin.getCharList(), Operator.class), QuestionUtil.fatherListToSonList(question.getCharList(), Operator.class))) {
//只有一个运算符说明重复
if (QuestionUtil.fatherListToSonList(question.getCharList(), Operator.class).size() == 1) {
return true;
}
//构建运算符优先链表
List<Operator> o1 = QuestionUtil.buildLink(QuestionUtil.fatherListToSonList(origin.getCharList(), Operator.class), origin.getParenthesesList());
List<Operator> o2 = QuestionUtil.buildLink(QuestionUtil.fatherListToSonList(question.getCharList(), Operator.class), question.getParenthesesList());
//比较运算符优先链表是否相同
for (int i = 0; i < o1.size(); i++) {
if (!o1.get(i).getOperator().equals(o2.get(i).getOperator())) {
return false;
}
}
//根据优先链表逐一比较
List<Char> charList1 = new LinkedList<>();
List<Char> charList2 = new LinkedList<>();
charList1.addAll(origin.getCharList());
charList2.addAll(question.getCharList());
List<String> stringList1 = new LinkedList<>();
List<String> stringList2 = new LinkedList<>();
for (int i = 0; i < o1.size() - 1; i ++) {
int index1 = charList1.indexOf(o1.get(i));
int index2 = charList2.indexOf(o2.get(i));
stringList1.add(((Number)charList1.get(index1 - 1)).getOutput());
stringList1.add(((Number)charList1.get(index1 + 1)).getOutput());
stringList2.add(((Number)charList2.get(index2 - 1)).getOutput());
stringList2.add(((Number)charList2.get(index2 + 1)).getOutput());
if (!QuestionUtil.isListEqual(stringList1, stringList2)) {
return false;
}
stringList1.clear();
stringList2.clear();
Number n = MathUtil.calculate((Number)charList1.get(index1 - 1), o1.get(i), (Number)charList1.get(index1 + 1));
for (int j = 0; j < 3; j++) {
charList1.remove(index1 - 1);
charList2.remove(index2 - 1);
}
charList1.add(index1 - 1, n);
charList2.add(index2 - 1, n);
}
return true;
}
}
}
return false;
}
public boolean isOperatorRepeat(List<Operator> operatorList1, List<Operator> operatorList2) {
if (!(operatorList1.size() == operatorList2.size())) {
return false;
}
List<String> stringList1 = operatorList1.stream().map(Operator::getOperator).collect(Collectors.toList());
List<String> stringList2 = operatorList2.stream().map(Operator::getOperator).collect(Collectors.toList());
return QuestionUtil.isListEqual(stringList1, stringList2);
}
}
其中用于生成优先运算符链表的方法：
/**
* 构建运算符优先运算链表
* @param operatorList
* @param pList
* @return
*/
public static List<Operator> buildLink(List<Operator> operatorList, List<Parentheses> pList) {
if (operatorList.size() == 1) {
return operatorList;
}
List<Operator> originList = new LinkedList<>(operatorList);
List<Parentheses> parenthesesList = new LinkedList<>(pList);
List<Operator> calculateList = new LinkedList<>();
//如果有括号，找到最优先的括号
Parentheses priorityParentheses;
if (parenthesesList.size() != 0) {
priorityParentheses = parenthesesList.get(0);
for (int i = 1; i < parenthesesList.size(); i++) {
Parentheses p = parenthesesList.get(i);
if (p.getEndNId() - p.getStartNId() < priorityParentheses.getEndNId() - priorityParentheses.getStartNId()) {
priorityParentheses = p;
} else if (p.getEndNId() - p.getStartNId() == priorityParentheses.getEndNId() - priorityParentheses.getStartNId() && p.getStartNId() < priorityParentheses.getStartNId()) {
priorityParentheses = p;
}
}
parenthesesList.remove(priorityParentheses);
int start = priorityParentheses.getStartNId();
int end = priorityParentheses.getEndNId() - 1;
operatorList = QuestionUtil.findCharById(operatorList, start, end);
}
List<Operator> tempOs = new LinkedList<>();
for (Operator o: operatorList) {
if (o.getOperator().equals(OperatorEnum.MULTIPLICATION.getOperator()) || o.getOperator().equals(OperatorEnum.DIVISION.getOperator())) {
((LinkedList<Operator>) calculateList).addLast(o);
} else {
((LinkedList<Operator>) tempOs).addLast(o);
}
}
for (Operator o: tempOs) {
((LinkedList<Operator>) calculateList).addLast(o);
}
//删除已添加到链表的运算符
for (Operator o: calculateList) {
originList.remove(o);
}
if (originList.size() == 0) {
return calculateList;
} else {
calculateList.addAll(buildLink(originList, parenthesesList));
return calculateList;
}
}
通用于各部分的四则运算运算方法（传入两个数和运算符可返回计算结果）
public static Number calculate(Number n1, Operator o, Number n2) {
CalculateFraction cf1 = n1.getCalculate();
CalculateFraction cf2 = n2.getCalculate();
//如果是加法或减法
if (o.getOperator().equals(OperatorEnum.PLUS.getOperator()) || o.getOperator().equals(OperatorEnum.SUBTRACTION.getOperator())) {
//最小公倍数
int lcm = lcm(cf1.getDenominator(), cf2.getDenominator());
int a1 = cf1.getNumerator() * (lcm / cf1.getDenominator());
int a2 = cf2.getNumerator() * (lcm / cf2.getDenominator());
if (o.getOperator().equals(OperatorEnum.PLUS.getOperator())) {
Number n = reduction(a1 + a2, lcm).getNumber();
n.setNId(o.getOid());
return n;
} else {
//如果是负数，返回null
if (a1 < a2) {
return null;
}
Number n = reduction(a1 - a2, lcm).getNumber();
n.setNId(o.getOid());
return n;
}
}
//如果是乘法
if (o.getOperator().equals(OperatorEnum.MULTIPLICATION.getOperator())) {
Number n = reduction(cf1.getNumerator() * cf2.getNumerator(), cf1.getDenominator() * cf2.getDenominator()).getNumber();
n.setNId(o.getOid());
return n;
}
//如果是除法
if (cf2.getNumerator() == 0) {//如果被除数是0，返回null
return null;
}
Number n = reduction(cf1.getNumerator() * cf2.getDenominator(), cf1.getDenominator() * cf2.getNumerator()).getNumber();
n.setNId(o.getOid());
return n;
}
测试运行
生成10个四则运算：
输出到文件的结果：
验证答案对错功能：
在第1、6、7题填上正确的答案，其他题填错误的答案或者不填
运行结果：
生成代码时，如果没有输入-r参数，报错：
生成更多的题目：
生成10000道题目，平均用时2s多：
由于题目过多，这里给出链接：
题目
答案
代码覆盖率：
PSP
| PSP2.1 | Personal Software Process Stages | 预估耗时（分钟） | 实际耗时（分钟） |
|---|---|---|---|
| Planning | 计划 | 30 | 30 |
| · Estimate | · 估计这个任务需要多少时间 | 30 | 30 |
| Development | 开发 | 1010 | 1375 |
| · Analysis | · 需求分析 (包括学习新技术) | 30 | 30 |
| · Design Spec | · 生成设计文档 | 20 | 20 |
| · Design Review | · 设计复审 (和同事审核设计文档) | 60 | 80 |
| · Coding Standard | · 代码规范 (为目前的开发制定合适的规范) | 30 | 45 |
| · Design | · 具体设计 | 180 | 300 |
| · Coding | · 具体编码 | 480 | 600 |
| · Code Review | · 代码复审 | 150 | 180 |
| · Test | · 测试（自我测试，修改代码，提交修改） | 60 | 120 |
| Reporting | 报告 | 135 | 155 |
| · Test Report | · 测试报告 | 90 | 100 |
| · Size Measurement | · 计算工作量 | 15 | 15 |
| · Postmortem & Process Improvement Plan | · 事后总结, 并提出过程改进计划 | 30 | 40 |
| 合计 | 1175 | 1560 |
项目小结
这次结对编程中，我主要负责代码编写，梁新男同学负责代码复审，我们两人首先分析了项目的需求，然后一起讨论项目各功能的实现，完成代码的设计文档和整体的结构设计，并对设计进行多次的探讨修改。在一开始的结构设计中，我们对于表达式的存储结构思考了很久，最终选择了效率与直观性并存的链表存储结构。在我写代码的过程中，两个人的交流确实比一个人考虑地更全面。比如在减法产生负数这个问题，一开始想着是要交换两个数字，后来经过我们的讨论发现这样会让题目重复的概率增大，也违反了随机的理念，于是最终做法是舍弃这道题重新生成。在这次磨合过程中，通过互相学习，掌握了更加高效的编程技巧。而在之后的代码复审中，梁新男同学发现了很多编程时没有注意到的细节问题，比如没有生成0的问题和没有产生嵌套括号的问题，从而很好地避免了bug的产生，增加了代码的健壮性，也让我们了解到别人的思维方式，从而提高了编程的质量。
