|
|
package com.mathlearning.model;
|
|
|
|
|
|
import java.util.ArrayList;
|
|
|
import java.util.HashSet;
|
|
|
import java.util.List;
|
|
|
import java.util.Random;
|
|
|
import java.util.Set;
|
|
|
|
|
|
public class QuestionGenerator {
|
|
|
private Random random = new Random();
|
|
|
|
|
|
public List<Question> generateQuestions(String level, int count) {
|
|
|
List<Question> questions = new ArrayList<>();
|
|
|
Set<String> questionTexts = new HashSet<>(); // 防止重复题目
|
|
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
|
Question question;
|
|
|
int attempt = 0;
|
|
|
do {
|
|
|
question = generateQuestion(level, i);
|
|
|
attempt++;
|
|
|
} while (questionTexts.contains(question.getQuestionText()) && attempt < 10);
|
|
|
|
|
|
if (question != null) {
|
|
|
questionTexts.add(question.getQuestionText());
|
|
|
questions.add(question);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return questions;
|
|
|
}
|
|
|
|
|
|
private Question generateQuestion(String level, int index) {
|
|
|
switch (level) {
|
|
|
case "小学":
|
|
|
return generatePrimaryQuestion(index);
|
|
|
case "初中":
|
|
|
return generateMiddleSchoolQuestion(index);
|
|
|
case "高中":
|
|
|
return generateHighSchoolQuestion(index);
|
|
|
default:
|
|
|
return generatePrimaryQuestion(index);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private Question generatePrimaryQuestion(int index) {
|
|
|
int operandCount = random.nextInt(4) + 2; // 2-5个操作数
|
|
|
int[] operands = new int[operandCount];
|
|
|
int[] operations = new int[operandCount - 1];
|
|
|
|
|
|
String questionText;
|
|
|
double answer;
|
|
|
|
|
|
do {
|
|
|
// 生成操作数
|
|
|
for (int i = 0; i < operandCount; i++) {
|
|
|
operands[i] = random.nextInt(100) + 1; // 1-100
|
|
|
}
|
|
|
|
|
|
// 生成操作符 (0: +, 1: -, 2: *, 3: /)
|
|
|
for (int i = 0; i < operations.length; i++) {
|
|
|
operations[i] = random.nextInt(4);
|
|
|
}
|
|
|
|
|
|
// 改进的括号逻辑：在可能改变计算顺序的地方加括号
|
|
|
boolean useParentheses = random.nextDouble() < 0.3 && operandCount >= 3;
|
|
|
int parenStart = -1;
|
|
|
int parenEnd = -1;
|
|
|
|
|
|
if (useParentheses) {
|
|
|
// 寻找适合加括号的位置（加减法周围）
|
|
|
parenStart = findSuitableParenthesesPosition(operations);
|
|
|
if (parenStart != -1) {
|
|
|
// 括号包含2-3个操作数
|
|
|
parenEnd = parenStart + 1;
|
|
|
if (parenEnd < operands.length - 1 && random.nextBoolean()) {
|
|
|
parenEnd++;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
questionText = buildPrimaryQuestionText(operands, operations, parenStart, parenEnd);
|
|
|
answer = calculatePrimaryAnswerWithParentheses(operands, operations, parenStart, parenEnd);
|
|
|
|
|
|
} while (answer < 0 || Double.isNaN(answer) || Double.isInfinite(answer));
|
|
|
|
|
|
return generateOptions(questionText, answer, "小学");
|
|
|
}
|
|
|
|
|
|
private Question generateMiddleSchoolQuestion(int index) {
|
|
|
int operandCount = random.nextInt(5) + 1; // 1-5个操作数
|
|
|
int[] operands = new int[operandCount];
|
|
|
int[] operations = new int[Math.max(0, operandCount - 1)]; // 操作符数组
|
|
|
boolean[] hasSpecialOp = new boolean[operandCount]; // 标记哪些操作数有平方或开根号
|
|
|
int[] specialOpTypes = new int[operandCount]; // 0:平方, 1:开根号
|
|
|
|
|
|
String questionText;
|
|
|
double answer;
|
|
|
|
|
|
// 确保至少有一个平方或开根号运算符
|
|
|
boolean hasSpecialOperation = false;
|
|
|
for (int i = 0; i < operandCount; i++) {
|
|
|
hasSpecialOp[i] = random.nextDouble() < 0.6; // 60%的概率有特殊运算
|
|
|
if (hasSpecialOp[i]) {
|
|
|
hasSpecialOperation = true;
|
|
|
specialOpTypes[i] = random.nextInt(2); // 随机选择平方或开根号
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果没有特殊运算，强制至少一个
|
|
|
if (!hasSpecialOperation && operandCount > 0) {
|
|
|
int idx = random.nextInt(operandCount);
|
|
|
hasSpecialOp[idx] = true;
|
|
|
specialOpTypes[idx] = random.nextInt(2);
|
|
|
}
|
|
|
|
|
|
// 生成合适的题目
|
|
|
do {
|
|
|
// 生成操作数
|
|
|
for (int i = 0; i < operandCount; i++) {
|
|
|
operands[i] = random.nextInt(100) + 1; // 1-100
|
|
|
}
|
|
|
|
|
|
// 生成操作符 (0: +, 1: -, 2: *, 3: /)
|
|
|
for (int i = 0; i < operations.length; i++) {
|
|
|
operations[i] = random.nextInt(4);
|
|
|
}
|
|
|
|
|
|
// 构建题目并计算答案
|
|
|
questionText = buildMiddleSchoolQuestionText(operands, operations, hasSpecialOp, specialOpTypes);
|
|
|
answer = calculateMiddleSchoolAnswer(operands, operations, hasSpecialOp, specialOpTypes);
|
|
|
|
|
|
} while (Double.isNaN(answer) || Double.isInfinite(answer) || Math.abs(answer) > 10000);
|
|
|
|
|
|
return generateOptions(questionText, answer, "初中");
|
|
|
}
|
|
|
|
|
|
private Question generateHighSchoolQuestion(int index) {
|
|
|
int operandCount = random.nextInt(5) + 1; // 1-5个操作数
|
|
|
int[] operands = new int[operandCount];
|
|
|
int[] operations = new int[Math.max(0, operandCount - 1)]; // 操作符数组
|
|
|
boolean[] hasTrigOp = new boolean[operandCount]; // 标记哪些操作数有三角函数
|
|
|
int[] trigFunctions = new int[operandCount]; // 0:sin, 1:cos, 2:tan
|
|
|
|
|
|
String questionText;
|
|
|
double answer;
|
|
|
|
|
|
// 确保至少有一个三角函数运算符
|
|
|
boolean hasTrigOperation = false;
|
|
|
for (int i = 0; i < operandCount; i++) {
|
|
|
hasTrigOp[i] = random.nextDouble() < 0.6; // 60%的概率有三角函数
|
|
|
if (hasTrigOp[i]) {
|
|
|
hasTrigOperation = true;
|
|
|
trigFunctions[i] = random.nextInt(3); // 随机选择三角函数
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果没有三角函数，强制至少一个
|
|
|
if (!hasTrigOperation && operandCount > 0) {
|
|
|
int idx = random.nextInt(operandCount);
|
|
|
hasTrigOp[idx] = true;
|
|
|
trigFunctions[idx] = random.nextInt(3);
|
|
|
}
|
|
|
|
|
|
// 生成合适的题目
|
|
|
do {
|
|
|
// 生成操作数
|
|
|
for (int i = 0; i < operandCount; i++) {
|
|
|
if (hasTrigOp[i]) {
|
|
|
// 三角函数使用特殊角度值
|
|
|
int[] specialAngles = {0, 15, 30, 45, 60, 75, 90};
|
|
|
operands[i] = specialAngles[random.nextInt(specialAngles.length)];
|
|
|
} else {
|
|
|
// 普通操作数使用1-100的随机数
|
|
|
operands[i] = random.nextInt(100) + 1;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 生成操作符 (0: +, 1: -, 2: *, 3: /)
|
|
|
for (int i = 0; i < operations.length; i++) {
|
|
|
operations[i] = random.nextInt(4);
|
|
|
}
|
|
|
|
|
|
// 构建题目并计算答案
|
|
|
questionText = buildHighSchoolQuestionText(operands, operations, hasTrigOp, trigFunctions);
|
|
|
answer = calculateHighSchoolAnswer(operands, operations, hasTrigOp, trigFunctions);
|
|
|
|
|
|
} while (Double.isNaN(answer) || Double.isInfinite(answer) || Math.abs(answer) > 10000);
|
|
|
|
|
|
return generateOptions(questionText, answer, "高中");
|
|
|
}
|
|
|
|
|
|
// 小学题目相关方法
|
|
|
private int findSuitableParenthesesPosition(int[] operations) {
|
|
|
// 寻找加减法操作符的位置，在这些地方加括号才有意义
|
|
|
List<Integer> suitablePositions = new ArrayList<>();
|
|
|
|
|
|
for (int i = 0; i < operations.length; i++) {
|
|
|
// 如果是加减法，且不是第一个操作符
|
|
|
if ((operations[i] == 0 || operations[i] == 1) && i > 0) {
|
|
|
suitablePositions.add(i);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (suitablePositions.isEmpty()) {
|
|
|
// 如果没有找到合适的加减法位置，随机选择一个位置
|
|
|
return operations.length > 1 ? random.nextInt(operations.length - 1) : -1;
|
|
|
}
|
|
|
|
|
|
// 从合适的位置中随机选择一个
|
|
|
return suitablePositions.get(random.nextInt(suitablePositions.size()));
|
|
|
}
|
|
|
|
|
|
private String buildPrimaryQuestionText(int[] operands, int[] operations, int parenStart, int parenEnd) {
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
|
|
for (int i = 0; i < operands.length; i++) {
|
|
|
// 在操作数前添加左括号
|
|
|
if (i == parenStart) {
|
|
|
sb.append("(");
|
|
|
}
|
|
|
|
|
|
// 添加操作数
|
|
|
sb.append(operands[i]);
|
|
|
|
|
|
// 在操作数后添加右括号（但要在操作符之前）
|
|
|
if (i == parenEnd) {
|
|
|
sb.append(")");
|
|
|
}
|
|
|
|
|
|
// 添加操作符（如果不是最后一个操作数）
|
|
|
if (i < operations.length) {
|
|
|
switch (operations[i]) {
|
|
|
case 0: sb.append(" + "); break;
|
|
|
case 1: sb.append(" - "); break;
|
|
|
case 2: sb.append(" × "); break;
|
|
|
case 3: sb.append(" ÷ "); break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
sb.append(" = ?");
|
|
|
|
|
|
return sb.toString();
|
|
|
}
|
|
|
|
|
|
private double calculatePrimaryAnswerWithParentheses(int[] operands, int[] operations, int parenStart, int parenEnd) {
|
|
|
// 如果没有括号，使用原来的计算方法
|
|
|
if (parenStart == -1 || parenEnd == -1) {
|
|
|
return calculatePrimaryAnswer(operands, operations);
|
|
|
}
|
|
|
|
|
|
// 复制操作数和操作符
|
|
|
List<Integer> numbers = new ArrayList<>();
|
|
|
List<Integer> ops = new ArrayList<>();
|
|
|
|
|
|
for (int operand : operands) {
|
|
|
numbers.add(operand);
|
|
|
}
|
|
|
for (int operation : operations) {
|
|
|
ops.add(operation);
|
|
|
}
|
|
|
|
|
|
// 计算括号内的表达式
|
|
|
double parenthesesResult = calculateParenthesesContent(numbers, ops, parenStart, parenEnd);
|
|
|
|
|
|
// 验证括号计算结果是否有效
|
|
|
if (parenthesesResult < 0 || Double.isNaN(parenthesesResult) || Double.isInfinite(parenthesesResult)) {
|
|
|
return -1;
|
|
|
}
|
|
|
|
|
|
// 用括号计算结果替换括号内的所有元素
|
|
|
replaceWithParenthesesResult(numbers, ops, parenStart, parenEnd, parenthesesResult);
|
|
|
|
|
|
// 计算剩余表达式
|
|
|
return calculateWithoutParentheses(numbers, ops);
|
|
|
}
|
|
|
|
|
|
private double calculateParenthesesContent(List<Integer> numbers, List<Integer> ops, int start, int end) {
|
|
|
// 提取括号内的数字和操作符
|
|
|
List<Integer> parenNumbers = new ArrayList<>();
|
|
|
List<Integer> parenOps = new ArrayList<>();
|
|
|
|
|
|
for (int i = start; i <= end; i++) {
|
|
|
parenNumbers.add(numbers.get(i));
|
|
|
}
|
|
|
for (int i = start; i < end; i++) {
|
|
|
parenOps.add(ops.get(i));
|
|
|
}
|
|
|
|
|
|
// 计算括号内的表达式（精确计算）
|
|
|
return calculateWithoutParentheses(parenNumbers, parenOps);
|
|
|
}
|
|
|
|
|
|
private void replaceWithParenthesesResult(List<Integer> numbers, List<Integer> ops,
|
|
|
int start, int end, double result) {
|
|
|
// 计算需要移除的元素数量
|
|
|
int numCountToRemove = end - start + 1;
|
|
|
int opCountToRemove = end - start;
|
|
|
|
|
|
// 移除括号范围内的数字
|
|
|
for (int i = 0; i < numCountToRemove; i++) {
|
|
|
numbers.remove(start);
|
|
|
}
|
|
|
|
|
|
// 移除括号范围内的操作符
|
|
|
for (int i = 0; i < opCountToRemove; i++) {
|
|
|
ops.remove(start);
|
|
|
}
|
|
|
|
|
|
// 插入括号计算结果
|
|
|
numbers.add(start, (int) Math.round(result));
|
|
|
}
|
|
|
|
|
|
private double calculateWithoutParentheses(List<Integer> numbers, List<Integer> ops) {
|
|
|
// 转换为double列表进行计算（精确计算）
|
|
|
List<Double> doubleNumbers = new ArrayList<>();
|
|
|
for (Integer num : numbers) {
|
|
|
doubleNumbers.add(num.doubleValue());
|
|
|
}
|
|
|
|
|
|
// 先处理乘除法（精确计算）
|
|
|
for (int i = 0; i < ops.size(); i++) {
|
|
|
int op = ops.get(i);
|
|
|
if (op == 2 || op == 3) {
|
|
|
double left = doubleNumbers.get(i);
|
|
|
double right = doubleNumbers.get(i + 1);
|
|
|
double result;
|
|
|
|
|
|
if (op == 2) {
|
|
|
result = left * right;
|
|
|
} else {
|
|
|
if (right == 0) return Double.NaN;
|
|
|
result = left / right;
|
|
|
}
|
|
|
|
|
|
doubleNumbers.set(i, result);
|
|
|
doubleNumbers.remove(i + 1);
|
|
|
ops.remove(i);
|
|
|
i--;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 处理加减法（精确计算）
|
|
|
double result = doubleNumbers.get(0);
|
|
|
for (int i = 0; i < ops.size(); i++) {
|
|
|
int op = ops.get(i);
|
|
|
double nextNum = doubleNumbers.get(i + 1);
|
|
|
|
|
|
if (op == 0) {
|
|
|
result += nextNum;
|
|
|
} else {
|
|
|
if (result < nextNum) return -1;
|
|
|
result -= nextNum;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 只在最后结果保留2位小数
|
|
|
return Math.round(result * 100) / 100.0;
|
|
|
}
|
|
|
|
|
|
private double calculatePrimaryAnswer(int[] operands, int[] operations) {
|
|
|
// 转换为double列表（精确计算）
|
|
|
List<Double> numbers = new ArrayList<>();
|
|
|
List<Integer> ops = new ArrayList<>();
|
|
|
|
|
|
for (int operand : operands) {
|
|
|
numbers.add((double) operand);
|
|
|
}
|
|
|
for (int operation : operations) {
|
|
|
ops.add(operation);
|
|
|
}
|
|
|
|
|
|
// 处理乘除法（精确计算）
|
|
|
for (int i = 0; i < ops.size(); i++) {
|
|
|
int op = ops.get(i);
|
|
|
if (op == 2 || op == 3) {
|
|
|
double left = numbers.get(i);
|
|
|
double right = numbers.get(i + 1);
|
|
|
double result;
|
|
|
|
|
|
if (op == 2) {
|
|
|
result = left * right;
|
|
|
} else {
|
|
|
if (right == 0) return Double.NaN;
|
|
|
result = left / right;
|
|
|
}
|
|
|
|
|
|
numbers.set(i, result);
|
|
|
numbers.remove(i + 1);
|
|
|
ops.remove(i);
|
|
|
i--;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 处理加减法（精确计算）
|
|
|
double result = numbers.get(0);
|
|
|
for (int i = 0; i < ops.size(); i++) {
|
|
|
int op = ops.get(i);
|
|
|
double nextNum = numbers.get(i + 1);
|
|
|
|
|
|
if (op == 0) {
|
|
|
result += nextNum;
|
|
|
} else {
|
|
|
if (result < nextNum) return -1;
|
|
|
result -= nextNum;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 只在最后结果保留2位小数
|
|
|
return Math.round(result * 100) / 100.0;
|
|
|
}
|
|
|
|
|
|
// 初中题目相关方法
|
|
|
private String buildMiddleSchoolQuestionText(int[] operands, int[] operations, boolean[] hasSpecialOp, int[] specialOpTypes) {
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
|
|
for (int i = 0; i < operands.length; i++) {
|
|
|
if (i > 0) {
|
|
|
switch (operations[i - 1]) {
|
|
|
case 0: sb.append(" + "); break;
|
|
|
case 1: sb.append(" - "); break;
|
|
|
case 2: sb.append(" × "); break;
|
|
|
case 3: sb.append(" ÷ "); break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (hasSpecialOp[i]) {
|
|
|
if (specialOpTypes[i] == 0) {
|
|
|
// 平方
|
|
|
sb.append(operands[i]).append("²");
|
|
|
} else {
|
|
|
// 开根号
|
|
|
sb.append("√").append(operands[i]);
|
|
|
}
|
|
|
} else {
|
|
|
sb.append(operands[i]);
|
|
|
}
|
|
|
}
|
|
|
sb.append(" = ?");
|
|
|
|
|
|
return sb.toString();
|
|
|
}
|
|
|
|
|
|
private double calculateMiddleSchoolAnswer(int[] operands, int[] operations, boolean[] hasSpecialOp, int[] specialOpTypes) {
|
|
|
// 先处理特殊运算（平方和开根号）- 精确计算
|
|
|
double[] processedValues = new double[operands.length];
|
|
|
for (int i = 0; i < operands.length; i++) {
|
|
|
if (hasSpecialOp[i]) {
|
|
|
if (specialOpTypes[i] == 0) {
|
|
|
// 平方
|
|
|
processedValues[i] = operands[i] * operands[i];
|
|
|
} else {
|
|
|
// 开根号
|
|
|
processedValues[i] = Math.sqrt(operands[i]);
|
|
|
}
|
|
|
} else {
|
|
|
processedValues[i] = operands[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 然后按照小学的计算逻辑处理（精确计算）
|
|
|
List<Double> numbers = new ArrayList<>();
|
|
|
List<Integer> ops = new ArrayList<>();
|
|
|
|
|
|
for (double value : processedValues) {
|
|
|
numbers.add(value);
|
|
|
}
|
|
|
for (int operation : operations) {
|
|
|
ops.add(operation);
|
|
|
}
|
|
|
|
|
|
// 处理乘除法（精确计算）
|
|
|
for (int i = 0; i < ops.size(); i++) {
|
|
|
int op = ops.get(i);
|
|
|
if (op == 2 || op == 3) {
|
|
|
double left = numbers.get(i);
|
|
|
double right = numbers.get(i + 1);
|
|
|
double result;
|
|
|
|
|
|
if (op == 2) {
|
|
|
result = left * right;
|
|
|
} else {
|
|
|
if (right == 0) return Double.NaN;
|
|
|
result = left / right;
|
|
|
}
|
|
|
|
|
|
numbers.set(i, result);
|
|
|
numbers.remove(i + 1);
|
|
|
ops.remove(i);
|
|
|
i--;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 处理加减法（精确计算）
|
|
|
double result = numbers.get(0);
|
|
|
for (int i = 0; i < ops.size(); i++) {
|
|
|
int op = ops.get(i);
|
|
|
double nextNum = numbers.get(i + 1);
|
|
|
|
|
|
if (op == 0) {
|
|
|
result += nextNum;
|
|
|
} else {
|
|
|
result -= nextNum;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 只在最后结果保留2位小数
|
|
|
return Math.round(result * 100) / 100.0;
|
|
|
}
|
|
|
|
|
|
// 高中题目相关方法
|
|
|
private String buildHighSchoolQuestionText(int[] operands, int[] operations, boolean[] hasTrigOp, int[] trigFunctions) {
|
|
|
StringBuilder sb = new StringBuilder();
|
|
|
|
|
|
for (int i = 0; i < operands.length; i++) {
|
|
|
if (i > 0) {
|
|
|
switch (operations[i - 1]) {
|
|
|
case 0: sb.append(" + "); break;
|
|
|
case 1: sb.append(" - "); break;
|
|
|
case 2: sb.append(" × "); break;
|
|
|
case 3: sb.append(" ÷ "); break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (hasTrigOp[i]) {
|
|
|
switch (trigFunctions[i]) {
|
|
|
case 0: sb.append("sin(").append(operands[i]).append("°)"); break;
|
|
|
case 1: sb.append("cos(").append(operands[i]).append("°)"); break;
|
|
|
case 2: sb.append("tan(").append(operands[i]).append("°)"); break;
|
|
|
}
|
|
|
} else {
|
|
|
sb.append(operands[i]);
|
|
|
}
|
|
|
}
|
|
|
sb.append(" = ?");
|
|
|
|
|
|
return sb.toString();
|
|
|
}
|
|
|
|
|
|
private double calculateHighSchoolAnswer(int[] operands, int[] operations, boolean[] hasTrigOp, int[] trigFunctions) {
|
|
|
// 先处理三角函数运算（精确计算）
|
|
|
double[] processedValues = new double[operands.length];
|
|
|
for (int i = 0; i < operands.length; i++) {
|
|
|
if (hasTrigOp[i]) {
|
|
|
double radians = Math.toRadians(operands[i]);
|
|
|
switch (trigFunctions[i]) {
|
|
|
case 0:
|
|
|
processedValues[i] = Math.sin(radians);
|
|
|
break;
|
|
|
case 1:
|
|
|
processedValues[i] = Math.cos(radians);
|
|
|
break;
|
|
|
case 2:
|
|
|
// 避免tan(90°)等无效值
|
|
|
if (operands[i] % 180 == 90 && operands[i] % 360 != 270) {
|
|
|
return Double.NaN;
|
|
|
}
|
|
|
processedValues[i] = Math.tan(radians);
|
|
|
break;
|
|
|
default:
|
|
|
processedValues[i] = 0;
|
|
|
}
|
|
|
} else {
|
|
|
processedValues[i] = operands[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 然后按照常规计算逻辑处理（精确计算）
|
|
|
List<Double> numbers = new ArrayList<>();
|
|
|
List<Integer> ops = new ArrayList<>();
|
|
|
|
|
|
for (double value : processedValues) {
|
|
|
numbers.add(value);
|
|
|
}
|
|
|
for (int operation : operations) {
|
|
|
ops.add(operation);
|
|
|
}
|
|
|
|
|
|
// 处理乘除法（精确计算）
|
|
|
for (int i = 0; i < ops.size(); i++) {
|
|
|
int op = ops.get(i);
|
|
|
if (op == 2 || op == 3) {
|
|
|
double left = numbers.get(i);
|
|
|
double right = numbers.get(i + 1);
|
|
|
double result;
|
|
|
|
|
|
if (op == 2) {
|
|
|
result = left * right;
|
|
|
} else {
|
|
|
if (right == 0) return Double.NaN;
|
|
|
result = left / right;
|
|
|
}
|
|
|
|
|
|
numbers.set(i, result);
|
|
|
numbers.remove(i + 1);
|
|
|
ops.remove(i);
|
|
|
i--;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 处理加减法（精确计算）
|
|
|
double result = numbers.get(0);
|
|
|
for (int i = 0; i < ops.size(); i++) {
|
|
|
int op = ops.get(i);
|
|
|
double nextNum = numbers.get(i + 1);
|
|
|
|
|
|
if (op == 0) {
|
|
|
result += nextNum;
|
|
|
} else {
|
|
|
result -= nextNum;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 只在最后结果保留2位小数
|
|
|
return Math.round(result * 100) / 100.0;
|
|
|
}
|
|
|
|
|
|
// 生成选项的通用方法
|
|
|
private Question generateOptions(String questionText, double answer, String level) {
|
|
|
String[] options = new String[4];
|
|
|
Set<String> usedValues = new HashSet<>();
|
|
|
|
|
|
// 检查答案是否为整数
|
|
|
boolean isIntegerAnswer = (answer == (int) answer);
|
|
|
|
|
|
// 格式化正确答案
|
|
|
String correctAnswer = formatAnswer(answer);
|
|
|
options[0] = correctAnswer;
|
|
|
usedValues.add(correctAnswer);
|
|
|
|
|
|
// 生成错误答案
|
|
|
for (int i = 1; i < 4; i++) {
|
|
|
String wrongAnswer;
|
|
|
int attempts = 0;
|
|
|
do {
|
|
|
// 基于正确答案生成错误答案
|
|
|
double wrongValue;
|
|
|
double offset = (random.nextDouble() * 5) + 1; // 1-6的偏移量
|
|
|
|
|
|
if (isIntegerAnswer) {
|
|
|
// 如果答案是整数，生成整数错误答案
|
|
|
int intAnswer = (int) answer;
|
|
|
int intOffset = random.nextInt(10) + 1; // 1-10的整数偏移
|
|
|
if (random.nextBoolean()) {
|
|
|
wrongValue = intAnswer + intOffset;
|
|
|
} else {
|
|
|
wrongValue = Math.max(1, intAnswer - intOffset);
|
|
|
}
|
|
|
// 确保是整数
|
|
|
wrongValue = (int) wrongValue;
|
|
|
} else {
|
|
|
// 如果答案是小数，生成小数错误答案
|
|
|
if (random.nextBoolean()) {
|
|
|
wrongValue = answer + offset;
|
|
|
} else {
|
|
|
wrongValue = answer - offset;
|
|
|
}
|
|
|
// 保留2位小数
|
|
|
wrongValue = Math.round(wrongValue * 100) / 100.0;
|
|
|
}
|
|
|
|
|
|
wrongAnswer = formatAnswer(wrongValue);
|
|
|
attempts++;
|
|
|
} while (usedValues.contains(wrongAnswer) && attempts < 20);
|
|
|
|
|
|
options[i] = wrongAnswer;
|
|
|
usedValues.add(wrongAnswer);
|
|
|
}
|
|
|
|
|
|
// 打乱选项顺序
|
|
|
shuffleArray(options);
|
|
|
|
|
|
// 找到正确答案的新位置
|
|
|
int correctIndex = 0;
|
|
|
for (int i = 0; i < options.length; i++) {
|
|
|
if (options[i].equals(correctAnswer)) {
|
|
|
correctIndex = i;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return new Question(questionText, options, correctIndex, level);
|
|
|
}
|
|
|
|
|
|
private String formatAnswer(double answer) {
|
|
|
if (answer == (int) answer) {
|
|
|
return String.valueOf((int) answer); // 整数不显示小数
|
|
|
} else {
|
|
|
return String.format("%.2f", answer); // 小数保留2位
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void shuffleArray(String[] array) {
|
|
|
for (int i = array.length - 1; i > 0; i--) {
|
|
|
int j = random.nextInt(i + 1);
|
|
|
String temp = array[i];
|
|
|
array[i] = array[j];
|
|
|
array[j] = temp;
|
|
|
}
|
|
|
}
|
|
|
} |
