|
|
|
@ -1,337 +1,358 @@
|
|
|
|
package util;
|
|
|
|
package util;
|
|
|
|
|
|
|
|
|
|
|
|
import generator.Problem;
|
|
|
|
import generator.Problem;
|
|
|
|
|
|
|
|
|
|
|
|
import java.util.*;
|
|
|
|
import java.util.*;
|
|
|
|
|
|
|
|
|
|
|
|
public class ExpressionUtils {
|
|
|
|
public class ExpressionUtils {
|
|
|
|
private static Random rand = new Random();
|
|
|
|
private static Random rand = new Random();
|
|
|
|
|
|
|
|
|
|
|
|
private static final String[] OPS_PRIMARY = {"+", "-", "*", "/"};
|
|
|
|
private static final String[] OPS_PRIMARY = {"+", "-", "*", "/"};
|
|
|
|
private static final String[] OPS_MIDDLE = {"+", "-", "*", "/"};
|
|
|
|
private static final String[] OPS_MIDDLE = {"+", "-", "*", "/"};
|
|
|
|
|
|
|
|
//private static final String[] OPS_HIGH = {"+", "-", "*", "/", "^2", "sqrt"};
|
|
|
|
public static String randomNumber() {
|
|
|
|
|
|
|
|
return String.valueOf(rand.nextInt(100) + 1);
|
|
|
|
|
|
|
|
}
|
|
|
|
public static String randomNumber() {
|
|
|
|
|
|
|
|
return String.valueOf(rand.nextInt(100) + 1);
|
|
|
|
// --- 表达式求解和选项生成辅助方法 ---
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// --- 表达式求解和选项生成辅助方法 ---
|
|
|
|
public static double solveExpression(String expr) {
|
|
|
|
|
|
|
|
String parsableExpr = expr
|
|
|
|
public static double solveExpression(String expr) {
|
|
|
|
.replaceAll("(\\d+|\\([^)]+\\))\\^2", "pow($1, 2)")
|
|
|
|
// 预处理表达式，确保格式正确
|
|
|
|
.replaceAll("sqrt\\s+(\\d+)", "sqrt($1)")
|
|
|
|
String parsableExpr = expr
|
|
|
|
.replaceAll("\\s+", " ");
|
|
|
|
.replaceAll("(\\d+|\\([^)]+\\))\\^2", "pow($1, 2)") // 处理平方
|
|
|
|
|
|
|
|
.replaceAll("sqrt\\s+(\\d+)", "sqrt($1)") // 处理缺少括号的sqrt
|
|
|
|
try {
|
|
|
|
.replaceAll("\\s+", " "); // 标准化空格
|
|
|
|
return new ExpressionParser(parsableExpr).parse();
|
|
|
|
|
|
|
|
} catch (Exception e) {
|
|
|
|
try {
|
|
|
|
System.err.println("Error parsing expression: '" + expr + "'. Parsable version: '" + parsableExpr + "'. Error: " + e.getMessage());
|
|
|
|
return new Object() {
|
|
|
|
return Double.NaN;
|
|
|
|
int pos = -1, ch;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
void nextChar() {
|
|
|
|
|
|
|
|
ch = (++pos < parsableExpr.length()) ? parsableExpr.charAt(pos) : -1;
|
|
|
|
|
|
|
|
}
|
|
|
|
private static class ExpressionParser {
|
|
|
|
|
|
|
|
private final String expr;
|
|
|
|
boolean eat(int charToEat) {
|
|
|
|
private int pos = -1, ch;
|
|
|
|
while (ch == ' ') nextChar();
|
|
|
|
|
|
|
|
if (ch == charToEat) {
|
|
|
|
public ExpressionParser(String expr) {
|
|
|
|
nextChar();
|
|
|
|
this.expr = expr;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
void nextChar() {
|
|
|
|
}
|
|
|
|
ch = (++pos < expr.length()) ? expr.charAt(pos) : -1;
|
|
|
|
|
|
|
|
}
|
|
|
|
double parse() {
|
|
|
|
|
|
|
|
nextChar();
|
|
|
|
boolean eat(int charToEat) {
|
|
|
|
double x = parseExpression();
|
|
|
|
while (ch == ' ') {
|
|
|
|
if (pos < parsableExpr.length()) throw new RuntimeException("Unexpected: " + (char) ch);
|
|
|
|
nextChar();
|
|
|
|
return x;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (ch == charToEat) {
|
|
|
|
|
|
|
|
nextChar();
|
|
|
|
double parseExpression() {
|
|
|
|
return true;
|
|
|
|
double x = parseTerm();
|
|
|
|
}
|
|
|
|
for (; ; ) {
|
|
|
|
return false;
|
|
|
|
if (eat('+')) x += parseTerm(); // addition
|
|
|
|
}
|
|
|
|
else if (eat('-')) x -= parseTerm(); // subtraction
|
|
|
|
|
|
|
|
else return x;
|
|
|
|
double parse() {
|
|
|
|
}
|
|
|
|
nextChar();
|
|
|
|
}
|
|
|
|
double x = parseExpression();
|
|
|
|
|
|
|
|
if (pos < expr.length()) {
|
|
|
|
double parseTerm() {
|
|
|
|
throw new RuntimeException("Unexpected: " + (char) ch);
|
|
|
|
double x = parseFactor();
|
|
|
|
}
|
|
|
|
for (; ; ) {
|
|
|
|
return x;
|
|
|
|
if (eat('*')) x *= parseFactor(); // multiplication
|
|
|
|
}
|
|
|
|
else if (eat('/')) { // division
|
|
|
|
|
|
|
|
double divisor = parseFactor();
|
|
|
|
double parseExpression() {
|
|
|
|
if (divisor == 0) throw new ArithmeticException("Division by zero");
|
|
|
|
double x = parseTerm();
|
|
|
|
x /= divisor;
|
|
|
|
for (;;) {
|
|
|
|
} else return x;
|
|
|
|
if (eat('+')) {
|
|
|
|
}
|
|
|
|
x += parseTerm();
|
|
|
|
}
|
|
|
|
} else if (eat('-')) {
|
|
|
|
|
|
|
|
x -= parseTerm();
|
|
|
|
double parseFactor() {
|
|
|
|
} else {
|
|
|
|
if (eat('+')) return parseFactor(); // unary plus
|
|
|
|
return x;
|
|
|
|
if (eat('-')) return -parseFactor(); // unary minus
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
double x;
|
|
|
|
}
|
|
|
|
int startPos = this.pos;
|
|
|
|
|
|
|
|
if (eat('(')) { // parentheses
|
|
|
|
double parseTerm() {
|
|
|
|
x = parseExpression();
|
|
|
|
double x = parseFactor();
|
|
|
|
eat(')');
|
|
|
|
for (;;) {
|
|
|
|
} else if ((ch >= '0' && ch <= '9') || ch == '.') { // numbers
|
|
|
|
if (eat('*')) {
|
|
|
|
while ((ch >= '0' && ch <= '9') || ch == '.') nextChar();
|
|
|
|
x *= parseFactor();
|
|
|
|
x = Double.parseDouble(parsableExpr.substring(startPos, this.pos));
|
|
|
|
} else if (eat('/')) {
|
|
|
|
} else if (ch >= 'a' && ch <= 'z') { // functions
|
|
|
|
double divisor = parseFactor();
|
|
|
|
while (ch >= 'a' && ch <= 'z') nextChar();
|
|
|
|
if (divisor == 0) {
|
|
|
|
String func = parsableExpr.substring(startPos, this.pos);
|
|
|
|
throw new ArithmeticException("Division by zero");
|
|
|
|
x = parseFactor();
|
|
|
|
}
|
|
|
|
switch (func) {
|
|
|
|
x /= divisor;
|
|
|
|
case "sqrt":
|
|
|
|
} else {
|
|
|
|
x = Math.sqrt(x);
|
|
|
|
return x;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case "sin":
|
|
|
|
}
|
|
|
|
x = Math.sin(Math.toRadians(x));
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case "cos":
|
|
|
|
double parseFactor() {
|
|
|
|
x = Math.cos(Math.toRadians(x));
|
|
|
|
if (eat('+')) {
|
|
|
|
break;
|
|
|
|
return parseFactor();
|
|
|
|
case "tan":
|
|
|
|
}
|
|
|
|
x = Math.tan(Math.toRadians(x));
|
|
|
|
if (eat('-')) {
|
|
|
|
break;
|
|
|
|
return -parseFactor();
|
|
|
|
case "pow":
|
|
|
|
}
|
|
|
|
eat(',');
|
|
|
|
|
|
|
|
double y = parseExpression();
|
|
|
|
double x;
|
|
|
|
x = Math.pow(x, y);
|
|
|
|
int startPos = this.pos;
|
|
|
|
eat(')');
|
|
|
|
if (eat('(')) {
|
|
|
|
break;
|
|
|
|
x = parseExpression();
|
|
|
|
default:
|
|
|
|
eat(')');
|
|
|
|
throw new RuntimeException("Unknown function: " + func);
|
|
|
|
} else if ((ch >= '0' && ch <= '9') || ch == '.') {
|
|
|
|
}
|
|
|
|
while ((ch >= '0' && ch <= '9') || ch == '.') {
|
|
|
|
} else {
|
|
|
|
nextChar();
|
|
|
|
throw new RuntimeException("Unexpected: " + (char) ch);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
x = Double.parseDouble(expr.substring(startPos, this.pos));
|
|
|
|
|
|
|
|
} else if (ch >= 'a' && ch <= 'z') {
|
|
|
|
return x;
|
|
|
|
while (ch >= 'a' && ch <= 'z') {
|
|
|
|
}
|
|
|
|
nextChar();
|
|
|
|
}.parse();
|
|
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
|
|
String func = expr.substring(startPos, this.pos);
|
|
|
|
System.err.println("Error parsing expression: '" + expr + "'. Parsable version: '" + parsableExpr + "'. Error: " + e.getMessage());
|
|
|
|
x = parseFunction(func); // 委托给新的辅助方法
|
|
|
|
return Double.NaN;
|
|
|
|
} else {
|
|
|
|
}
|
|
|
|
throw new RuntimeException("Unexpected: " + (char) ch);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return x;
|
|
|
|
|
|
|
|
}
|
|
|
|
private static String formatResult(double result) {
|
|
|
|
|
|
|
|
if (Double.isNaN(result)) {
|
|
|
|
|
|
|
|
return "Error";
|
|
|
|
private double parseFunction(String func) {
|
|
|
|
}
|
|
|
|
double x = parseFactor();
|
|
|
|
if (Math.abs(result - Math.round(result)) < 0.0001) {
|
|
|
|
switch (func) {
|
|
|
|
return String.valueOf((int) Math.round(result));
|
|
|
|
case "sqrt": return Math.sqrt(x);
|
|
|
|
}
|
|
|
|
case "sin": return Math.sin(Math.toRadians(x));
|
|
|
|
return String.format("%.2f", result);
|
|
|
|
case "cos": return Math.cos(Math.toRadians(x));
|
|
|
|
}
|
|
|
|
case "tan": return Math.tan(Math.toRadians(x));
|
|
|
|
|
|
|
|
case "pow":
|
|
|
|
/**
|
|
|
|
eat(',');
|
|
|
|
* MODIFICATION: 确保为整数答案生成整数干扰项
|
|
|
|
double y = parseExpression();
|
|
|
|
*/
|
|
|
|
eat(')');
|
|
|
|
private static String generateDistractor(double correctResult, List<String> existingOptions) {
|
|
|
|
return Math.pow(x, y);
|
|
|
|
if (Double.isNaN(correctResult)) {
|
|
|
|
default:
|
|
|
|
return String.valueOf(rand.nextInt(100));
|
|
|
|
throw new RuntimeException("Unknown function: " + func);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
// 检查正确答案是否为整数
|
|
|
|
}
|
|
|
|
boolean isIntegerResult = Math.abs(correctResult - Math.round(correctResult)) < 0.0001;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
double distractor;
|
|
|
|
private static String formatResult(double result) {
|
|
|
|
String distractorStr;
|
|
|
|
if (Double.isNaN(result)) {
|
|
|
|
|
|
|
|
return "Error";
|
|
|
|
do {
|
|
|
|
}
|
|
|
|
if (isIntegerResult) {
|
|
|
|
if (Math.abs(result - Math.round(result)) < 0.0001) {
|
|
|
|
// 生成一个整数干扰项
|
|
|
|
return String.valueOf((int) Math.round(result));
|
|
|
|
int offset = rand.nextInt(20) + 1; // 扩大随机范围以避免重复
|
|
|
|
}
|
|
|
|
distractor = rand.nextBoolean() ? Math.round(correctResult) + offset : Math.round(correctResult) - offset;
|
|
|
|
return String.format("%.2f", result);
|
|
|
|
// 确保干扰项不为负数
|
|
|
|
}
|
|
|
|
if (distractor < 0) {
|
|
|
|
|
|
|
|
distractor = Math.round(correctResult) + offset;
|
|
|
|
private static String generateDistractor(double correctResult, List<String> existingOptions) {
|
|
|
|
}
|
|
|
|
if (Double.isNaN(correctResult)) {
|
|
|
|
} else {
|
|
|
|
return String.valueOf(rand.nextInt(100));
|
|
|
|
// 答案是小数，则生成小数干扰项
|
|
|
|
}
|
|
|
|
distractor = correctResult +
|
|
|
|
boolean isIntegerResult = Math.abs(correctResult - Math.round(correctResult)) < 0.0001;
|
|
|
|
(rand.nextInt(10) + 1) * (rand.nextBoolean() ? 1 : -1) +
|
|
|
|
double distractor;
|
|
|
|
(rand.nextDouble() * 0.9);
|
|
|
|
String distractorStr;
|
|
|
|
}
|
|
|
|
|
|
|
|
distractorStr = formatResult(distractor);
|
|
|
|
do {
|
|
|
|
} while (existingOptions.contains(distractorStr)); // 确保选项不重复
|
|
|
|
if (isIntegerResult) {
|
|
|
|
return distractorStr;
|
|
|
|
int offset = rand.nextInt(20) + 1;
|
|
|
|
}
|
|
|
|
distractor = rand.nextBoolean() ? Math.round(correctResult) + offset : Math.round(correctResult) - offset;
|
|
|
|
|
|
|
|
if (distractor < 0) {
|
|
|
|
|
|
|
|
distractor = Math.round(correctResult) + offset;
|
|
|
|
public static List<String> generateOptions(double correctResult) {
|
|
|
|
}
|
|
|
|
List<String> options = new ArrayList<>();
|
|
|
|
} else {
|
|
|
|
options.add(formatResult(correctResult));
|
|
|
|
distractor = correctResult + (rand.nextInt(10) + 1) * (rand.nextBoolean() ? 1 : -1) + (rand.nextDouble() * 0.9);
|
|
|
|
|
|
|
|
}
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
distractorStr = formatResult(distractor);
|
|
|
|
options.add(generateDistractor(correctResult, options));
|
|
|
|
} while (existingOptions.contains(distractorStr));
|
|
|
|
}
|
|
|
|
return distractorStr;
|
|
|
|
|
|
|
|
}
|
|
|
|
Collections.shuffle(options);
|
|
|
|
|
|
|
|
return options;
|
|
|
|
public static List<String> generateOptions(double correctResult) {
|
|
|
|
}
|
|
|
|
List<String> options = new ArrayList<>();
|
|
|
|
|
|
|
|
options.add(formatResult(correctResult));
|
|
|
|
public static Problem createProblem(String expression) {
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
|
|
double result = solveExpression(expression);
|
|
|
|
options.add(generateDistractor(correctResult, options));
|
|
|
|
|
|
|
|
}
|
|
|
|
// 如果解析失败，返回null，让调用者重新生成
|
|
|
|
Collections.shuffle(options);
|
|
|
|
if (Double.isNaN(result)) {
|
|
|
|
return options;
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public static Problem createProblem(String expression) {
|
|
|
|
String correctAnswerOption = formatResult(result);
|
|
|
|
double result = solveExpression(expression);
|
|
|
|
List<String> options = generateOptions(result);
|
|
|
|
if (Double.isNaN(result)) {
|
|
|
|
return new Problem(expression, result, options, correctAnswerOption);
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
String correctAnswerOption = formatResult(result);
|
|
|
|
// --- 题目生成方法 ---
|
|
|
|
List<String> options = generateOptions(result);
|
|
|
|
|
|
|
|
return new Problem(expression, result, options, correctAnswerOption);
|
|
|
|
private static int getDivisor(int dividend) {
|
|
|
|
}
|
|
|
|
List<Integer> divisors = new ArrayList<>();
|
|
|
|
|
|
|
|
for (int j = 1; j <= dividend; j++) {
|
|
|
|
// --- 题目生成方法 ---
|
|
|
|
if (dividend % j == 0) {
|
|
|
|
|
|
|
|
divisors.add(j);
|
|
|
|
private static int getDivisor(int dividend) {
|
|
|
|
}
|
|
|
|
List<Integer> divisors = new ArrayList<>();
|
|
|
|
}
|
|
|
|
for (int j = 1; j <= dividend; j++) {
|
|
|
|
return divisors.get(rand.nextInt(divisors.size()));
|
|
|
|
if (dividend % j == 0) {
|
|
|
|
}
|
|
|
|
divisors.add(j);
|
|
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
|
|
}
|
|
|
|
* MODIFICATION: 增加答案非负、括号数量和操作数关联的逻辑
|
|
|
|
return divisors.get(rand.nextInt(divisors.size()));
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
public static Problem generatePrimaryExpr() {
|
|
|
|
|
|
|
|
Problem problem;
|
|
|
|
public static Problem generatePrimaryExpr() {
|
|
|
|
double result;
|
|
|
|
Problem problem;
|
|
|
|
|
|
|
|
double result;
|
|
|
|
do {
|
|
|
|
do {
|
|
|
|
// 生成 2 到 4 个操作数
|
|
|
|
int operands = rand.nextInt(3) + 2;
|
|
|
|
int operands = rand.nextInt(3) + 2;
|
|
|
|
List<String> parts = new ArrayList<>();
|
|
|
|
List<String> parts = new ArrayList<>();
|
|
|
|
for (int i = 0; i < operands; i++) {
|
|
|
|
|
|
|
|
if (i > 0) {
|
|
|
|
for (int i = 0; i < operands; i++) {
|
|
|
|
parts.add(OPS_PRIMARY[rand.nextInt(OPS_PRIMARY.length)]);
|
|
|
|
if (i > 0) {
|
|
|
|
}
|
|
|
|
parts.add(OPS_PRIMARY[rand.nextInt(OPS_PRIMARY.length)]);
|
|
|
|
if (operands >= 3 && rand.nextBoolean() && i < operands - 1) {
|
|
|
|
}
|
|
|
|
int num1 = rand.nextInt(50) + 1;
|
|
|
|
|
|
|
|
String innerOp = OPS_PRIMARY[rand.nextInt(OPS_PRIMARY.length)];
|
|
|
|
// 仅当操作数 >= 3 时，才有可能生成括号
|
|
|
|
int num2 = innerOp.equals("/") ? getDivisor(num1) : rand.nextInt(50) + 1;
|
|
|
|
if (operands >= 3 && rand.nextBoolean() && i < operands - 1) {
|
|
|
|
parts.add("(" + num1 + " " + innerOp + " " + num2 + ")");
|
|
|
|
int num1 = rand.nextInt(50) + 1;
|
|
|
|
i++;
|
|
|
|
String innerOp = OPS_PRIMARY[rand.nextInt(OPS_PRIMARY.length)];
|
|
|
|
} else {
|
|
|
|
int num2;
|
|
|
|
int num;
|
|
|
|
if (innerOp.equals("/")) {
|
|
|
|
if (i > 0 && parts.get(parts.size() - 1).equals("/")) {
|
|
|
|
num2 = getDivisor(num1);
|
|
|
|
String dividendStr = parts.get(parts.size() - 2);
|
|
|
|
} else {
|
|
|
|
if (dividendStr.startsWith("(")) {
|
|
|
|
num2 = rand.nextInt(50) + 1;
|
|
|
|
parts.set(parts.size() - 1, OPS_PRIMARY[rand.nextInt(3)]);
|
|
|
|
}
|
|
|
|
num = rand.nextInt(100) + 1;
|
|
|
|
parts.add("(" + num1 + " " + innerOp + " " + num2 + ")");
|
|
|
|
} else {
|
|
|
|
i++; // 括号表达式计为2个操作数
|
|
|
|
num = getDivisor(Integer.parseInt(dividendStr));
|
|
|
|
} else {
|
|
|
|
}
|
|
|
|
int num;
|
|
|
|
} else {
|
|
|
|
if (i > 0 && parts.get(parts.size() - 1).equals("/")) {
|
|
|
|
num = rand.nextInt(100) + 1;
|
|
|
|
String dividendStr = parts.get(parts.size() - 2);
|
|
|
|
}
|
|
|
|
if (dividendStr.startsWith("(")) {
|
|
|
|
parts.add(String.valueOf(num));
|
|
|
|
// 为避免 (a+b)/c 这种复杂情况无法保证整数结果，直接替换运算符
|
|
|
|
}
|
|
|
|
parts.set(parts.size() - 1, OPS_PRIMARY[rand.nextInt(3)]); // +, -, *
|
|
|
|
}
|
|
|
|
num = rand.nextInt(100) + 1;
|
|
|
|
String expression = String.join(" ", parts);
|
|
|
|
} else {
|
|
|
|
problem = createProblem(expression);
|
|
|
|
int dividend = Integer.parseInt(dividendStr);
|
|
|
|
result = (problem != null) ? problem.getResult() : Double.NaN;
|
|
|
|
num = getDivisor(dividend);
|
|
|
|
} while (result < 0 || Double.isNaN(result) || Math.abs(result - Math.round(result)) > 0.0001);
|
|
|
|
}
|
|
|
|
return problem;
|
|
|
|
} else {
|
|
|
|
}
|
|
|
|
num = rand.nextInt(100) + 1;
|
|
|
|
|
|
|
|
}
|
|
|
|
public static Problem generateMiddleExpr() {
|
|
|
|
parts.add(String.valueOf(num));
|
|
|
|
int operands = rand.nextInt(5) + 1;
|
|
|
|
}
|
|
|
|
StringBuilder expr = new StringBuilder();
|
|
|
|
}
|
|
|
|
boolean hasSquareOrSqrt = false;
|
|
|
|
String expression = String.join(" ", parts);
|
|
|
|
for (int i = 0; i < operands; i++) {
|
|
|
|
problem = createProblem(expression);
|
|
|
|
if (i > 0) {
|
|
|
|
result = problem.getResult();
|
|
|
|
expr.append(" ").append(OPS_MIDDLE[rand.nextInt(OPS_MIDDLE.length)]).append(" ");
|
|
|
|
// 循环直到答案为非负整数
|
|
|
|
}
|
|
|
|
} while (result < 0 || Double.isNaN(result) || Math.abs(result - Math.round(result)) > 0.0001);
|
|
|
|
int num = rand.nextInt(100) + 1;
|
|
|
|
|
|
|
|
if (!hasSquareOrSqrt && rand.nextBoolean()) {
|
|
|
|
return problem;
|
|
|
|
expr.append(rand.nextBoolean() ? "sqrt(" + num + ")" : num + "^2");
|
|
|
|
}
|
|
|
|
hasSquareOrSqrt = true;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
expr.append(num);
|
|
|
|
public static Problem generateMiddleExpr() {
|
|
|
|
}
|
|
|
|
int operands = rand.nextInt(5) + 1;
|
|
|
|
}
|
|
|
|
StringBuilder expr = new StringBuilder();
|
|
|
|
if (!hasSquareOrSqrt) {
|
|
|
|
boolean hasSquareOrSqrt = false;
|
|
|
|
expr.append(" + ").append(rand.nextInt(50) + 1).append("^2");
|
|
|
|
|
|
|
|
}
|
|
|
|
for (int i = 0; i < operands; i++) {
|
|
|
|
return createProblem(expr.toString());
|
|
|
|
if (i > 0) {
|
|
|
|
}
|
|
|
|
expr.append(" ").append(OPS_MIDDLE[rand.nextInt(OPS_MIDDLE.length)]).append(" ");
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int num = rand.nextInt(100) + 1;
|
|
|
|
public static Problem generateHighExpr() {
|
|
|
|
if (!hasSquareOrSqrt && rand.nextBoolean()) {
|
|
|
|
final int maxAttempts = 10;
|
|
|
|
expr.append(rand.nextBoolean() ? "sqrt(" + num + ")" : num + "^2");
|
|
|
|
for (int attempts = 0; attempts < maxAttempts; attempts++) {
|
|
|
|
hasSquareOrSqrt = true;
|
|
|
|
String expression = buildHighLevelExpression();
|
|
|
|
} else {
|
|
|
|
Problem problem = createProblem(expression);
|
|
|
|
expr.append(num);
|
|
|
|
if (problem != null) {
|
|
|
|
}
|
|
|
|
return problem;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
System.err.println("生成高中题目失败，尝试次数: " + (attempts + 1) + ", 表达式: " + expression);
|
|
|
|
if (!hasSquareOrSqrt) {
|
|
|
|
}
|
|
|
|
expr.append(" + ").append(rand.nextInt(50) + 1).append("^2");
|
|
|
|
return createProblem("sin(30) + cos(60)"); // Fallback
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return createProblem(expr.toString());
|
|
|
|
private static String buildHighLevelExpression() {
|
|
|
|
}
|
|
|
|
int operands = rand.nextInt(3) + 2; // 2-4个操作数
|
|
|
|
|
|
|
|
StringBuilder expr = new StringBuilder();
|
|
|
|
public static Problem generateHighExpr() {
|
|
|
|
boolean hasTrig = false;
|
|
|
|
int attempts = 0;
|
|
|
|
|
|
|
|
final int maxAttempts = 10;
|
|
|
|
for (int i = 0; i < operands; i++) {
|
|
|
|
|
|
|
|
if (i > 0) {
|
|
|
|
while (attempts < maxAttempts) {
|
|
|
|
String[] validOps = {"+", "-", "*", "/"};
|
|
|
|
int operands = rand.nextInt(3) + 2; // 2-4个操作数
|
|
|
|
expr.append(" ").append(validOps[rand.nextInt(validOps.length)]).append(" ");
|
|
|
|
StringBuilder expr = new StringBuilder();
|
|
|
|
}
|
|
|
|
boolean hasTrig = false;
|
|
|
|
if (!hasTrig && (i == operands - 1 || rand.nextBoolean())) {
|
|
|
|
|
|
|
|
appendTrigonometricFunction(expr);
|
|
|
|
for (int i = 0; i < operands; i++) {
|
|
|
|
hasTrig = true;
|
|
|
|
if (i > 0) {
|
|
|
|
} else {
|
|
|
|
String[] validOps = {"+", "-", "*", "/"};
|
|
|
|
appendOtherOperand(expr, hasTrig);
|
|
|
|
String op = validOps[rand.nextInt(validOps.length)];
|
|
|
|
}
|
|
|
|
expr.append(" ").append(op).append(" ");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ensureTrigonometricFunction(expr, hasTrig);
|
|
|
|
|
|
|
|
return expr.toString();
|
|
|
|
// 强制至少有一个操作数是三角函数
|
|
|
|
}
|
|
|
|
if (!hasTrig && (i == operands - 1 || rand.nextBoolean())) {
|
|
|
|
|
|
|
|
String[] funcs = {"sin", "cos", "tan"};
|
|
|
|
|
|
|
|
String func = funcs[rand.nextInt(funcs.length)];
|
|
|
|
private static void appendTrigonometricFunction(StringBuilder expr) {
|
|
|
|
int angle = rand.nextInt(90) + 1; // 1-90度
|
|
|
|
String[] funcs = {"sin", "cos", "tan"};
|
|
|
|
expr.append(func).append("(").append(angle).append(")");
|
|
|
|
String func = funcs[rand.nextInt(funcs.length)];
|
|
|
|
hasTrig = true;
|
|
|
|
int angle = rand.nextInt(90) + 1;
|
|
|
|
} else {
|
|
|
|
expr.append(func).append("(").append(angle).append(")");
|
|
|
|
// 其他操作数可以是普通数字、平方或开方
|
|
|
|
}
|
|
|
|
int num = rand.nextInt(100) + 1;
|
|
|
|
|
|
|
|
if (rand.nextBoolean() && hasTrig) { // 确保已经有三角函数后再添加其他函数
|
|
|
|
|
|
|
|
if (rand.nextBoolean()) {
|
|
|
|
private static void appendOtherOperand(StringBuilder expr, boolean hasTrig) {
|
|
|
|
expr.append(num).append("^2");
|
|
|
|
int num = rand.nextInt(100) + 1;
|
|
|
|
} else {
|
|
|
|
if (hasTrig && rand.nextBoolean()) {
|
|
|
|
expr.append("sqrt(").append(num).append(")");
|
|
|
|
expr.append(rand.nextBoolean() ? num + "^2" : "sqrt(" + num + ")");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
} else {
|
|
|
|
expr.append(num);
|
|
|
|
expr.append(num);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
private static void ensureTrigonometricFunction(StringBuilder expr, boolean hasTrig) {
|
|
|
|
// 如果没有三角函数，强制添加一个
|
|
|
|
if (!hasTrig) {
|
|
|
|
if (!hasTrig) {
|
|
|
|
String trigPart = " + " + "sin" + "(" + (rand.nextInt(90) + 1) + ")";
|
|
|
|
String[] funcs = {"sin", "cos", "tan"};
|
|
|
|
if (rand.nextBoolean()) {
|
|
|
|
String func = funcs[rand.nextInt(funcs.length)];
|
|
|
|
expr.insert(0, trigPart.substring(3) + " + ");
|
|
|
|
int angle = rand.nextInt(90) + 1;
|
|
|
|
} else {
|
|
|
|
|
|
|
|
expr.append(trigPart);
|
|
|
|
if (rand.nextBoolean()) {
|
|
|
|
}
|
|
|
|
// 在开头添加
|
|
|
|
}
|
|
|
|
expr.insert(0, func + "(" + angle + ") + ");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
// 在结尾添加
|
|
|
|
|
|
|
|
expr.append(" + ").append(func).append("(").append(angle).append(")");
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
hasTrig = true;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
String expression = expr.toString();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// 验证表达式
|
|
|
|
|
|
|
|
Problem problem = createProblem(expression);
|
|
|
|
|
|
|
|
if (problem != null) {
|
|
|
|
|
|
|
|
return problem;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
attempts++;
|
|
|
|
|
|
|
|
System.err.println("生成高中题目失败，尝试次数: " + attempts + ", 表达式: " + expression);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return createProblem("sin(30) + cos(60)");
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
