对分数及整数的计算

/***

* 相加操作

*/

ADD("+") {

@Override

public String calculate(String a, String b) {

boolean flagA = a.contains("/");

boolean flagB = b.contains("/");

//两个都是分数

if (flagA && flagB) {

int[] anInt = ResolveUtil.analysis(a);

int[] bnInt = ResolveUtil.analysis(b);

//以AB为分母

int denominator = anInt[1] * bnInt[1];

//相加后的分子

int molecule = anInt[0] * bnInt[1] + anInt[1] * bnInt[0];

return ResolveUtil.createFraction(molecule, denominator);

} else if (flagA) {

int[] anInt = ResolveUtil.analysis(a);

//直接更新分子便可

anInt[0] += Integer.parseInt(b) * anInt[1];

return ResolveUtil.createFraction(anInt[0], anInt[1]);

} else if (flagB) {

int[] bnInt = ResolveUtil.analysis(b);

//直接更新分子便可

bnInt[0] += Integer.parseInt(a) * bnInt[1];

return ResolveUtil.createFraction(bnInt[0], bnInt[1]);

} else {

return String.valueOf(Integer.parseInt(a) + Integer.parseInt(b));

}

}

},

/***

* 相乘操作

*/

MULTIPLY("×") {

@Override

public String calculate(String a, String b) {

boolean flagA = a.contains("/");

boolean flagB = b.contains("/");

if (flagA && flagB) {

int[] anInt = ResolveUtil.analysis(a);

int[] bnInt = ResolveUtil.analysis(b);

//以AB为分母

int denominator = anInt[1] * bnInt[1];

//分子相乘

int molecule = anInt[0] * bnInt[0];

return ResolveUtil.createFraction(molecule, denominator);

} else if (flagA) {

int[] anInt = ResolveUtil.analysis(a);

return ResolveUtil.createFraction(anInt[0] * Integer.parseInt(b), anInt[1]);

} else if (flagB) {

int[] bnInt = ResolveUtil.analysis(b);

return ResolveUtil.createFraction(bnInt[0] * Integer.parseInt(a), bnInt[1]);

} else {

return String.valueOf(Integer.parseInt(a) * Integer.parseInt(b));

}

}

},

/***

* 相除操作

*/

DIVIDE("÷") {

@Override

public String calculate(String a, String b) {

//除法，从另外一种角度来说，是乘法的倒转，所以，只需要把b分子分母倒过来用乘法就行了

boolean flag = b.contains("/");

//新的数b的字符串

String newB;

//判断b是否为分数

if (flag) {

int[] bnInt = ResolveUtil.analysis(b);

newB = ResolveUtil.createFraction(bnInt[1], bnInt[0]);

} else {

newB = 1 + "/" + b;

}

return Symbol.MULTIPLY.calculate(a, newB);

}

},

/***

* 相减操作

*/

SUB("-") {

@Override

public String calculate(String a, String b) {

//减是加的特例，把b弄成-就可以了

return Symbol.ADD.calculate(a, "-" + b);

}

},

中缀转后缀表达式

/***

* 中缀表达式转换成后缀表达式

* @param expression 表达式

* @return 数组

*/

private String[] middleToAfter(String expression) {

//用来转换的栈

Stack stack = new Stack<>();

//表达式每个字符前后都会生成一个空格

String[] strings = expression.split("\\s");

//返回的list

List stringList = new ArrayList<>(strings.length);

for (int index = 0; index < strings.length; index++) {

if ('0' <= strings[index].charAt(0) && strings[index].charAt(0) <= '9') {

//数字直接输出

stringList.add(strings[index]);

} else if (strings[index].equals(Symbol.BEGIN.getSymbol())) {

//开始括号压进栈

stack.push(strings[index]);

} else if (strings[index].equals(Symbol.END.getSymbol())) {

//把所有运算符都出栈

while (!stack.peek().equals(Symbol.BEGIN.getSymbol())) {

stringList.add(stack.pop());

}

//出栈开始括号

stack.pop();

} else if (strings[index].equals(Symbol.MULTIPLY.getSymbol())

|| strings[index].equals(Symbol.DIVIDE.getSymbol())) {

//判断上一级符号是什么

boolean flag = !stack.isEmpty() && (stack.peek().equals(Symbol.MULTIPLY.getSymbol())

|| stack.peek().equals(Symbol.DIVIDE.getSymbol()));

if (flag) {

stringList.add(stack.pop());

}

stack.push(strings[index]);

} else if (strings[index].equals(Symbol.SUB.getSymbol())

|| strings[index].equals(Symbol.ADD.getSymbol())) {

//此处应该为+，-号

boolean flag = !stack.isEmpty() && (stack.peek().equals(Symbol.ADD.getSymbol())

|| stack.peek().equals(Symbol.SUB.getSymbol()));

if (flag) {

stringList.add(stack.pop());

}

stack.push(strings[index]);

} else {

//有其他符号，直接跳出，可能是=号

break;

}

}

while (!stack.isEmpty()) {

stringList.add(stack.pop());

}

//返回数组

return stringList.toArray(new String[0]);

}

后缀计算

/***

* 计算表达式

* @param expression 表达式

* @param permit 允许存在负数的运算过程

* @return 结果

*/

public String calculate(String expression, boolean permit) {

if (expression == null) {

return null;

}

//先生成后缀表达式数组，然后手动控制数组进行操作

String[] afterExp = middleToAfter(expression);

Stack stack = new Stack<>();

try {

for (int index = 0; index < afterExp.length; index++) {

if (afterExp[index].matches("[0-9/']+")) {

stack.push(afterExp[index]);

} else {

String b = stack.pop();

String a = stack.pop();

String result = Symbol.value(afterExp[index]).calculate(a, b);

//计算过程中存在负数，重新生成表达式

if (result.startsWith("-") && !permit) {

return null;

}

stack.push(result);

}

}

} catch (NullPointerException e) {

e.printStackTrace();

} catch (Exception e) {

System.out.println("存在表达式不合法");

}

return stack.pop();

}

生成表达式

/***

* 生成表达式

* @return 生成表达式

*/

private String generateExpression() {

//随机运算符大小

int operatorSize = (int) (Math.random() * MAX_OPERATOR_SIZE) + 1;

int numberSize = operatorSize + 1;

//判断是否需要生成括号,1/4的概率

boolean flag = (int) (Math.random() * MAX_OPERATOR_SIZE) == 0;

//标记(产生的位置)

int mark = -1;

if (flag) {

//随机插入括号的位置

mark = (int) (Math.random() * operatorSize);

}

StringBuilder expression = new StringBuilder();

//遍历产生数字和符号，你一下我一下

for (int i = 0; i < numberSize; i++) {

if (mark == i) {

myAppend(expression, "(");

}

//生成数字

myAppend(expression, (int) (Math.random() * 2) == 0 ? generateFraction() : generateInt());

//判断是否加入结束符号，判断是否结尾

if (mark >= 0 && mark < i) {

//已经到了表达式结尾, 此时必须结束

if (i == operatorSize) {

myAppend(expression, ")");

break;

}

//判断是否需要结束

flag = (int) (Math.random() * 2) == 0;

if (flag) {

myAppend(expression, ")");

mark = -1;

}

}

if (i < operatorSize) {

//然后生成一个操作符

myAppend(expression, generateOperator());

}

}

//最后补充等号

expression.append("=");

return expression.toString();

}

去重校验

/***

* 检查表达式是否已经存在或者重复

* @param expression 表达式

* @param result 结果

* @return 是否重复

*/

private boolean checkExpressionExistAndResultIllegal(String expression, String result) {

if (Objects.isNull(result)) {

return true;

}

//当前没有表达式

if (nowExpressionSize == 0) {

return false;

}

//API的一些操作也是循环，效率低下，手动循环

for (int i = 0, j = nowExpressionSize - 1; i <= j; i++, j--) {

if (expressionList.get(i).equals(expression) || expressionList.get(j).equals(expression)) {

return true;

}

//查看是否答案有相同的

if (answerList.get(i).equals(result)) {

return checkCharEquals(expressionList.get(i), expression);

} else if (answerList.get(j).equals(result)) {

return checkCharEquals(expressionList.get(j), expression);

}

}

return false;

}

/***

*

* @param oldExpression 存在的表达式

* @param newExpression 还没存进去的表达式

* @return 相同，不相同

*/

private boolean checkCharEquals(String oldExpression, String newExpression) {

String[] oldExpressionArrays = oldExpression.split("\\s+");

String[] newExpressionArrays = newExpression.split("\\s+");

int oldExpressionNumber = 0;

int equalsNumber = 0;

//是否为数字

boolean flag;

//开始遍历

for (String oldString : oldExpressionArrays) {

flag = oldExpression.matches("[0-9'/]+");

if (flag) {

oldExpressionNumber++;

}

//比对

for (String newString : newExpressionArrays) {

if (oldString.equals(newString)) {

equalsNumber++;

}

}

}

答案校对

//保存正确/错误题号的队列

private List correctList = new ArrayList<>();

private List wrongList = new ArrayList<>();

/**

* 校验待检测文件状态

* @param exersicesFile

* @param myAnswer

* @Author Naren

*/

public void checkFile(String exersicesFile,String myAnswer) {

//存储表达式的文件

File expFile = new File(exersicesFile);//Exercise002.txt

//待校验答案的文件

File myAnsFile = new File(myAnswer);//myAnswers001.txt

//待校验答案文件不存在

if(!myAnsFile.exists()){

//System.out.println("未找到待检验答案文件。");

new Tips().displayTips("noExpTip.png");

return;

}

//如果表达式文件不存在

if(!expFile.exists()) {

//System.out.println("未找到指定题目文件。");

new Tips().displayTips("noAnsTip.png");

return;

}

//如果全部文件名都正确，检测待校对题目文件是否存在于系统生成历史中

String id = exersicesFile.substring(9,12);

String sysAnsFile = "Answers" + id + ".txt"; //Myapp.exe -e Exercises001.txt -a myAnswers001.txt

File ansFile = new File(sysAnsFile);//Answers002.txt(不存在)

//若系统中不存在与题目文件相符合的答案文件

if(!ansFile.exists()){

try {

FileReader fr = new FileReader(expFile);

BufferedReader br = new BufferedReader(fr);

String content = null;

ArrayList questionList = new ArrayList<>();

while((content = br.readLine()) != null){//(?m)^.*$

content = content.split("\\.")[1];

questionList.add(content);

}

//调用起廷方法获得答案队列

Expression ex = new Expression(new Calculate());

List answerList = ex.getCorrectAnswerList(questionList);

//比对

checkAnswer(myAnsFile,answerList);

} catch (Exception e) {

System.out.println("Class:AnswerChecking,Method:checkFile(String,String) is wrong!");

}

}else{

//调用本类检验方法比对答案文件

checkAnswer(myAnsFile,ansFile);

}

}

/**

* 将待校验答案文件与现场计算出的答案队列进行比对

* @param myAnswer

* @param answerList

* @author Naren

*/

private void checkAnswer(File myAnswer, List answerList){

try {

//待检测答案文件

FileReader fr1 = new FileReader(myAnswer);

BufferedReader br1 = new BufferedReader(fr1);

LinkedHashMap map1 = new LinkedHashMap<>();

String content = "";

while((content = br1.readLine()) != null){

content = content.replaceAll(" +", "").replaceAll("\uFEFF", "");

//map1待校验答案：key:序号，value:答案

map1.put(Integer.valueOf(content.split("\\.")[0]),content.split("\\.")[1]);

}

//开始比对

for (int i = 0; i < answerList.size(); i++) {

if(map1.containsKey(i + 1)){

if(map1.get(i + 1).equals(answerList.get(i))) {

correctList.add(i + 1);//正确题号添加进队列

}

else{

wrongList.add(i + 1);//错误题号添加进队列

}

}else{

//漏写

wrongList.add(i + 1);

}

}

//将校验结果写入文件

//System.out.println("检验信息已写入Grade.txt文件。");

new Tips().displayTips("checkSuccess.png");

new DataStorage().storeCheckInfo(correctList,wrongList);

} catch (Exception e) {

System.out.println("Class:AnswerChecking,Method:checkAnswer(File,List) is wrong!");

}

}

/**

* 【重载】将待校验答案文件与本地答案文件进行比对

* @param myAnswer 待校验答案文件

* @param ansFile 正确答案文件

* @author Naren

*/

private void checkAnswer(File myAnswer, File ansFile) {

try {

FileReader fr1 = new FileReader(myAnswer);

FileReader fr2 = new FileReader(ansFile);

BufferedReader br1 = new BufferedReader(fr1);

BufferedReader br2 = new BufferedReader(fr2);

LinkedHashMap map1 = new LinkedHashMap<>();//待检测 key:序号，value:答案

LinkedHashMap map2 = new LinkedHashMap<>();//正 确 key:序号，value:答案

//分别按行读出答案

String content = "";

while((content = br1.readLine()) != null){

content = content.replaceAll(" +", "").replaceAll("\uFEFF", "");

map1.put(Integer.valueOf(content.split("\\.")[0]),content.split("\\.")[1]);

}

while((content = br2.readLine()) != null){

content = content.replaceAll(" +", "").replaceAll("\uFEFF", "");

map2.put(Integer.valueOf(content.split("\\.")[0]),content.split("\\.")[1]);

}

//开始比对

for (int i = 0; i < map2.size(); i++) {

if(map1.containsKey(i + 1)){

if(map1.get(i + 1).equals(map2.get(i + 1))) {

correctList.add(i + 1);//正确题号添加进队列

}

else{

wrongList.add(i + 1);//错误题号添加进队列

}

}else{

//漏写

wrongList.add(i + 1);

}

}

//将校验结果写入文件

//System.out.println("检验信息已写入Grade.txt文件。");

new Tips().displayTips("checkSuccess.png");

new DataStorage().storeCheckInfo(correctList,wrongList);

} catch (Exception e) {

System.out.println("Class:AnswerChecking,Method:checkAnswer(File,File) is wrong!");

}

}