标签:code exce 个数 不重复 line ring 逆波兰式 命令 出现
合作者 刘彦享(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
Correct: 5 (1, 3, 5, 7, 9)
Wrong: 5 (2, 4, 6, 8, 10)
其中“:”后面的数字5表示对/错的题目的数量,括号内的是对/错题目的编号。为简单起见,假设输入的题目都是按照顺序编号的符合规范的题目。(完成)
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 两个功能也必须一起实现
/**
* 生成式子
* @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();
}
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("没有输入命令或者命令错误,请输入正确的命令!");
}
}
标签:code exce 个数 不重复 line ring 逆波兰式 命令 出现
原文地址:https://www.cnblogs.com/lyx708194/p/12696974.html