结对项目--四则运算生成器（Java）
GitHub地址
合作者 刘彦享（3118005010） 龙俊健（3118005011）
https://github.com/LYX708194/calculate
一、项目简介
说明
自然数：0, 1, 2, …。
真分数：1/2, 1/3, 2/3, 1/4, 1’1/2, …。
运算符：+, −, ×, ÷。
括号：(, )。
等号：=。
分隔符：空格（用于四则运算符和等号前后）。
算术表达式：
e = n | e1 + e2 | e1 − e2 | e1 × e2 | e1 ÷ e2 | (e),
其中e, e1和e2为表达式，n为自然数或真分数。
四则运算题目：e = ，其中e为算术表达式。
功能
-
使用 -n 参数控制生成题目的个数，例如 Myapp.exe -n 10 将生成10个题目。 （完成）
-
使用 -r 参数控制题目中数值（自然数、真分数和真分数分母）的范围，例如 Myapp.exe -r 10 将生成10以内（不包括10）的四则运算题目。该参数可以设置为1或其他自然数。该参数必须给定，否则程序报错并给出帮助信息。（完成）
-
生成的题目中计算过程不能产生负数，也就是说算术表达式中如果存在形如e1− e2的子表达式，那么e1≥ e2。 （完成）
-
生成的题目中如果存在形如e1÷ e2的子表达式，那么其结果应是真分数。 （完成）
-
每道题目中出现的运算符个数不超过3个。 （完成）
-
程序一次运行生成的题目不能重复，即任何两道题目不能通过有限次交换+和×左右的算术表达式变换为同一道题目。例如，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文件。 （完成）
-
在生成题目的同时，计算出所有题目的答案，并存入执行程序的当前目录下的Answers.txt文件。（完成）
-
程序应能支持一万道题目的生成。 （完成）
-
程序支持对给定的题目文件和答案文件，判定答案中的对错并进行数量统计，输入参数如下：Myapp.exe -e
.txt -a .txt，统计结果输出到文件Grade.txt，格式如下：
Correct: 5 (1, 3, 5, 7, 9)
Wrong: 5 (2, 4, 6, 8, 10)
其中“:”后面的数字5表示对/错的题目的数量，括号内的是对/错题目的编号。为简单起见，假设输入的题目都是按照顺序编号的符合规范的题目。（完成）
二、PSP表格
| PSP2.1 | Personal Software Process Stages | 预估耗时（分钟） | 实际耗时（分钟） |
|---|---|---|---|
| Planning | 计划 | 60 | 60 |
| · Estimate | · 估计这个任务需要多少时间 | 1600 | 2500 |
| Development | 开发 | 430 | 490 |
| · Analysis | · 需求分析 (包括学习新技术) | 100 | 120 |
| · Design Spec | · 生成设计文档 | 30 | 30 |
| · Design Review | · 设计复审 (和同事审核设计文档) | 20 | 20 |
| · Coding Standard | · 代码规范 (为目前的开发制定合适的规范) | 10 | 10 |
| · Design | · 具体设计 | 20 | 25 |
| · Coding | · 具体编码 | 900 | 1500 |
| · Code Review | · 代码复审 | 100 | 500 |
| · Test | · 测试（自我测试，修改代码，提交修改） | 30 | 25 |
| Reporting | 报告 | 40 | 55 |
| · Test Report | · 测试报告 | 15 | 20 |
| · Size Measurement | · 计算工作量 | 10 | 15 |
| · Postmortem & Process Improvement Plan | · 事后总结, 并提出过程改进计划 | 30 | 40 |
| 合计 | 1670 | 2680 |
三、思路
运算式的生成采用了随机生成的方法，另外计算结果采用了将中缀表达式转换成后缀表达式再用栈求。
对于式子的重复功能，采用set的不可重复性。一开始是用一定的规则对式子进行求hash值存进set中，后面发现额外消耗性能太大了，所以后面决定直接把答案当作hash存进set中，宁可错杀，不可放过，每次获得结果将其存入其中，如果添加失败则重复了，则重新生成式子。
其他功能要求则在具体实现进行约束，如不产生负数，真分数等等。
四、设计实现过程
根据需求对功能进行分割，一共有四个功能，分别为：
- -r 生成运算式的数值范围
- -n 生成运算式的数目
- -e 检查运算结果的题目文件
- -a 检查运算结果的答案文件
其中 -r 和 -n 两个功能必须一起实现， -e 和 -a 两个功能也必须一起实现
即可把这些功能分为两类
- 一类是生成运算式子，即-r和-n功能实现
- 一类是检查答案功能，即-e和-a功能实现
五、主要代码说明
- 生成式子（中缀表达式）
/**
* 生成式子
* @param p 生成数的范围
* @return 返回str[]数组，str[0]是假分数形式，str[1]是正常形式
*/
public static String[] getVal(int p){
String[] s = new String[2];
//操作数
Operation[] ops = new Operation[4];
for (int i = 0; i < 4; i++) {
ops[i] = getOp(p);
}
int[] n = new int[3];
for (int i = 0; i < 3; i++) {
n[i] = (int)(Math.random()*4);
}
//假分数形式
s[0] = ops[0].getValue()+on[n[0]]+ops[1].getValue()+on[n[1]]+ops[2].getValue()+on[n[2]]+ops[3].getValue();
//正常形式
s[1] = ops[0].getStr()+on[n[0]]+ops[1].getStr()+on[n[1]]+ops[2].getStr()+on[n[2]]+ops[3].getStr();
return s;
}
/**
* 生成操作数
* @Param 生成数的范围
* @return
*/
public static Operation getOp(int n){
Operation op = new Operation();
int a = (int)(Math.random()*(n)) ;
if (a == 0){
a = 1;
}
op.setA(a);
//有分数
if ((int)(Math.random()*(100)) > 60){
//分母默认在20以内
int fenMu = (int) (Math.random()*(20));
if (fenMu <= 1) fenMu = 5;
int fenZi = (int) (Math.random()*(100));
fenZi = fenZi % fenMu;
if (fenZi == 0){
fenZi = 1;
}
op.setB(fenZi+"/"+fenMu);
}
return op;
}
/**
* 把文件的式子转成分数形式
* @param s：文件的式子
* @return ：str[0]是文件式子序号，str[1]是分数式子
* 例子 "22. 15 + 22'7/8 - 5 x 4"
*/
public static String[] changeFile(String s){
//去掉序号
String[] split = s.split("\\.");
String[] ps = split[1].split("\\s+");
for (int i = 1; i < ps.length; i+=2) {
if (ps[i].contains("'")){
//es[0]为整数部分 ， es[1]为分数部分
String[] es = ps[i].split("'");
//fen[0]为分子，fen[1]为分母
String[] fen = es[1].split("/");
long fenzi = Long.parseLong(es[0]) * Long.parseLong(fen[1]) + Long.parseLong(fen[0]);
ps[i] = fenzi+"/"+fen[1];
}
}
StringBuilder sb = new StringBuilder();
for (int i = 1; i < ps.length; i++) {
sb.append(ps[i]+" ");
}
split[1] = sb.toString();
return split;
}
- 计算
/**
* 计算
* @param poland
* @return
*/
public static String calculate(String poland){
Stack stack = new Stack();
String result = "";
String[] split = poland.split("\\s+");
for (int i = 0; i < split.length; i++) {
//是操作数
if (split[i].matches("^[0-9]+.*")){
stack.push(split[i]);
}else {
String e2 = stack.pop();
String e1 = stack.pop();
if (split[i].equals("+")){
result = add(e1, e2);
}else if(split[i].equals("-")){
result = sub(e1,e2);
}else if (split[i].equals("x")) {
result = mul(e1,e2);
}else{
result = div(e1,e2);
}
if (result.equals("error") || result == null){
return "error";
}
//把计算结果入栈
stack.push(result);
}
}
result = stack.getTop();
//约分
if (result.contains("/")){
String[] qs = result.split("/");
long w1 = Long.parseLong(qs[0]);
long w2 = Long.parseLong(qs[1]);
long w = w1 % w2;
if (w == 0){
return w1/w2+"";
}else {
//整数部分
long a = (w1-w)/w2;
//分数部分
long reduce = reduce(w,w2);
w /= reduce;
w2 /= reduce;
if (a==0){
return w+"/"+w2;
}else {
return a+"'"+w+"/"+w2;
}
}
}
return stack.getTop();
}
/**
* 加法
* @return
*/
public static String add(String e1 , String e2 ){
if (e1 == null || e2 == null) return "error";
if (e1.contains("/")){
String[] e1s = e1.split("/");
long e1z = Long.parseLong(e1s[0]);
long e1m = Long.parseLong(e1s[1]);
if (e2.contains("/")){
String[] e2s = e2.split("/");
//分子
long e2z = Long.parseLong(e2s[0]);
//分母
long e2m = Long.parseLong(e2s[1]);
//计算
long ei = e1z * e2m + e2z * e1m;
long em = e1m * e2m;
//约分，避免数太大超界
long reduce = reduce(ei, em);
ei /= reduce;
em /= reduce;
return ei+"/"+em;
}else {
e1z = e1z + Long.parseLong(e2) * e1m;
long reduce = reduce(e1z, e1m);
e1z /= reduce;
e1m /= reduce;
return e1z+"/"+e1m;
}
}else {
if (e2.contains("/")){
String[] e2s = e2.split("/");
long e2z = Long.parseLong(e2s[0]);
long e2m = Integer.parseInt(e2s[1]);
e2z = e2z + Long.parseLong(e1) * e2m;
long reduce = reduce(e2z, e2m);
e2z /= reduce;
e2m /= reduce;
return e2z+"/"+e2m;
}else {
return (Long.parseLong(e1)+Long.parseLong(e2))+"";
}
}
}
/**
* 减法
* 若中间出现负数，返回 "error"
* @return
*/
public static String sub(String e1 , String e2 ){
if (e1 == null || e2 == null) return "error";
if (e1.contains("/")){
String[] e1s = e1.split("/");
int e1z = Integer.parseInt(e1s[0]);
int e1m = Integer.parseInt(e1s[1]);
// e1 e2都是分数
if (e2.contains("/")){
String[] e2s = e2.split("/");
//分子
long e2z = Long.parseLong(e2s[0]);
//分母
long e2m = Long.parseLong(e2s[1]);
//计算
long ei = e1z * e2m - e2z * e1m;
if (ei < 0){
return "error";
}
if (ei == 0){
return "0";
}
long em = e1m * e2m;
long reduce = reduce(ei, em);
ei /= reduce;
em /= reduce;
return ei+"/"+em;
}else {
// e1 是分数 e2是整数
e1z = e1z - Integer.parseInt(e2) * e1m;
if (e1z < 0) return "error";
if (e1z == 0) return "0";
long reduce = reduce(e1z, e1m);
e1z /= reduce;
e1m /= reduce;
return e1z+"/"+e1m;
}
}else {
//e1是整数，e2是分数
if (e2.contains("/")){
String[] e2s = e2.split("/");
long e2z = Long.parseLong(e2s[0]);
long e2m = Long.parseLong(e2s[1]);
e2z = Long.parseLong(e1) * e2m - e2z;
if (e2z < 0) return "error";
if (e2z == 0) return "0";
long reduce = reduce(e2z, e2m);
e2z /= reduce;
e2m /= reduce;
return e2z+"/"+e2m;
}else {
//e1 e2 都是整数
long result = Long.parseLong(e1)-Long.parseLong(e2);
if (result < 0){
return "error";
}
return result+"";
}
}
}
/**
* 乘法
* @return
*/
public static String mul( String e1 , String e2){
if (e1 == null || e2 == null) return "error";
if (e1.contains("/")){
String[] e1s = e1.split("/");
int e1z = Integer.parseInt(e1s[0]);
int e1m = Integer.parseInt(e1s[1]);
// e1 e2都是分数
if (e2.contains("/")){
String[] e2s = e2.split("/");
//分子
long e2z = Long.parseLong(e2s[0]);
//分母
long e2m = Long.parseLong(e2s[1]);
//计算
long ei = e1z * e2z;
if (ei == 0) return "0";
long em = e1m * e2m;
long reduce = reduce(ei, em);
ei /= reduce;
em /= reduce;
return ei+"/"+em;
}else {
// e1 是分数 e2是整数
e1z = e1z * Integer.parseInt(e2);
if (e1z < 0) return "error";
if (e1z == 0) return "0";
long reduce = reduce(e1z, e1m);
e1z /= reduce;
e1m /= reduce;
return e1z+"/"+e1m;
}
}else {
//e1是整数，e2是分数
if (e2.contains("/")){
String[] e2s = e2.split("/");
long e2z = Long.parseLong(e2s[0]);
long e2m = Long.parseLong(e2s[1]);
e2z = Long.parseLong(e1) * e2z;
if (e2z < 0) return "error";
if (e2z == 0) return "0";
long reduce = reduce(e2z, e2m);
e2z /= reduce;
e2m /= reduce;
return e2z+"/"+e2m;
}else {
//e1 e2 都是整数
long result = Long.parseLong(e1)*Long.parseLong(e2);
if (result < 0){
return "error";
}
return result+"";
}
}
}
/**
* 除法
* @return
*/
public static String div ( String e1 , String e2){
if (e1 == null || e2 == null) return "error";
if (e1.contains("/")){
String[] e1s = e1.split("/");
int e1z = Integer.parseInt(e1s[0]);
int e1m = Integer.parseInt(e1s[1]);
// e1 e2都是分数
if (e2.contains("/")){
String[] e2s = e2.split("/");
//分子
long e2z = Long.parseLong(e2s[0]);
//分母
long e2m = Long.parseLong(e2s[1]);
//计算
long ei = e1z * e2m;
if (ei == 0) return "0";
long em = e1m * e2z;
long reduce = reduce(ei, em);
ei /= reduce;
em /= reduce;
return ei+"/"+em;
}else {
// e1 是分数 e2是整数
e1m = e1m * Integer.parseInt(e2);
//分母不可为0
if (e1m <= 0){
return "error";
}
long reduce = reduce(e1z, e1m);
e1z /= reduce;
e1m /= reduce;
return e1z+"/"+e1m;
}
}else {
//e1是整数，e2是分数
if (e2.contains("/")){
String[] e2s = e2.split("/");
long e2z = Long.parseLong(e2s[0]);
long e2m = Long.parseLong(e2s[1]);
e2m = Long.parseLong(e1) * e2m;
if (e2m < 0) return "error";
if (e2m == 0) return "0";
long reduce = reduce(e2m, e2z);
e2m /= reduce;
e2z /= reduce;
return e2m+"/"+e2z;
}else {
//e1 e2 都是整数
if (Long.parseLong(e1) % Long.parseLong(e2) == 0){
return (Long.parseLong(e1)/Long.parseLong(e2))+"";
}else {
long e1z = Long.parseLong(e1);
long e2m = Long.parseLong(e2);
long reduce = reduce(e1z, e2m);
e1z /= reduce;
e2m /= reduce;
String result = e1z+"/"+e2m;
return result;
}
}
}
}
/**
* 约分分数
* @param a：分子
* @param b：分母
* @return
*/
public static long reduce(long a , long b){
long min = a < b ? a : b;
long c,d;
for( int i = 1;i <= min/2;i ++){
c = a > b ? a : b;//两个数字的大值
d = a < b ? a : b;//两个数字的小值
a = c % d;
b = d;
if(a == 0) {
return d;
}
}
return 1L;
}
- 两个功能的实现
/**
* 生成题目
* @param n 生成题目的个数
* @param r 生成题目中值的范围
*/
public static void generateFormulas(int n,int r) throws Exception {
BufferedWriter exercises = FileUtil.getFileOutputStream("./Exercises.txt");
BufferedWriter answers = FileUtil.getFileOutputStream("./Answers.txt");
for (int i = 0; i < n; i++) {
while (true){
String[] val = Generation.getVal(r);
String poland = Changes.changeToPoland(val[0]);
String result = Changes.calculate(poland);
if (set.add(result)){
if (!result.equals("error")){
exercises.write(i+1+". "+val[1]);
exercises.newLine();
answers.write(i+1+". "+result);
answers.newLine();
break;
}
}else{
continue;
}
}
}
exercises.close();
answers.close();
}
/**
* 通过输入的两个文件名检查答案是否正确
* @param exercisefile 式子文件名
* @param answerfile 答案文件名
* @throws Exception
*/
public static void checkAnswer(String exercisefile,String answerfile) throws Exception {
//读取式子文件和答案文件
BufferedReader exercise = FileUtil.getFileInputStream(exercisefile);
BufferedReader answer = FileUtil.getFileInputStream(answerfile);
//输出正确和错误序号到grade文件
BufferedWriter grade = FileUtil.getFileOutputStream("./Grade.txt");
if (exercise!=null&&answer!=null){
String formula;
String resultInFile;
//存储答案正确题目的序号
List<String> right = new ArrayList<String>();
//存储答案错误的题目的序号
List<String> wrong = new ArrayList<String>();
while ((formula=exercise.readLine())!=null){
//将此行的序号和式子分割并且将式子的真分数转化为假分数
String[] split1 = Generation.changeFile(formula);
//通过式子计算结果
String poland = Changes.changeToPoland(split1[1]);
String result = Changes.calculate(poland);
//获得答案文件的内容
resultInFile = answer.readLine();
String[] split2 = Generation.changeAnswerFile(resultInFile);
if (result == split2[1]||result.equals(split2[1])){
//答案正确，添加到正确list中
right.add(split1[0]);
}else{
//答案错误，添加到错误list中
wrong.add(split1[0]);
}
}
String s1 = "Correct: "+right.size()+" "+right;
String s2 = "Wrong: "+wrong.size()+" "+wrong;
grade.write(s1);
grade.newLine();
grade.write(s2);
}
//关闭流
exercise.close();
answer.close();
grade.close();
}
- main函数实现
public static void main(String[] args) throws Exception {
//生成式子数量参数
int n = 0;
//生成式子值范围参数
int r = 0;
//读取四则运算式子文件名
String exercisefile = null;
//读取答案文件名
String answerfile = null;
//标志，为真则表示是生成式子命令，为假则是检查答案命令
boolean isGernate = false;
//是否有命令的标志
boolean hasOrder = false;
int i =0;
while(i<args.length){
String s = args[i];
switch (s){
case "-n":
if (args[i+1].matches("\\d+")){
n = Integer.parseInt(args[i+1]);
isGernate = true;
hasOrder = true;
}
break;
case "-r":
if (args[i+1].matches("\\d+")){
r = Integer.parseInt(args[i+1]);
isGernate = true;
hasOrder = true;
}
break;
case "-e":
exercisefile = args[i+1];
isGernate = false;
hasOrder = true;
break;
case "-a":
answerfile = args[i+1];
isGernate = false;
hasOrder = true;
break;
}
i++;
}
//是否有命令输入
if (hasOrder){
//是生成式子命令
if (isGernate){
if (n <= 0||r <= 0){
System.out.println("没有输入 -n 命令或输入数值不为正数，正确格式为 -n 生成式子数 -r 生成数范围 ");
}else{
if (r > 150){
System.out.println("生成数的范围只能在0-150之间");
}else{
//命令正确，生成式子
System.out.println("命令正确，生成"+n+"道数值在"+r+"范围内的式子存在当前目录文件夹下的Exercises.txt和Answers.txt");
generateFormulas(n,r);
}
}
}else{ //是检查结果命令
if (exercisefile == null||answerfile == null){
//式子文件和答案文件存在空值
if (exercisefile == null){
System.out.println("没有输入 -e 命令，正确格式为 -e <exercisefile>.txt -a <answerfile>.txt ");
}else if (answerfile == null){
System.out.println("没有输入 -a 命令，正确格式为 -e <exercisefile>.txt -a <answerfile>.txt ");
}
}else{
System.out.println("命令正确，检查式子和答案是否正确的结果在当前目录文件夹下的Grade.txt");
checkAnswer(exercisefile,answerfile);
}
}
}else{
System.out.println("没有输入命令或者命令错误，请输入正确的命令！");
}
}
六、测试运行
- 生成10000道式子
- 生成式子
- 检查结果 （直接使用之前生成的文件，全部正确）
- 检查结果 （修改一些答案）
- 一些错误命令
七、总结
- 刘彦享
开始的项目都是将一些情况简单化，没有打算考虑得那么多，开始并不是用栈来写得，是直接对生成得式子进行计算，很蠢，后面看了一下博客，才和队友决定重构项目，把主要的计算方法重新写了，可以说前面浪费了很多没必要的时间吧，但也收获到了很多。因为是在线上搞的，很多时候沟通没有那么方便，造成了些许困难。 - 龙俊健
本来看到这个题目，感觉很难，因为不知道有逆波兰式的存在，所以开始时想的是用ifelse来区分式子的顺序。直到提交的前几天，觉得不行，才和队友决定重写项目。
我负责写式子的生成，还有计算，学习到了逆波兰式，收获不少。