Update ModifyUtils.java

doc/小初高数学学习软件 - 结对编程项目介绍.md

@@ -0,0 +1,208 @@
+# 小初高数学学习软件 - 结对编程项目介绍
+
+
+
+
+
+## 一、系统概述
+
+
+
+本系统是一个基于 Java 和 JavaFX 技术实现的桌面应用程序，旨在为小学、初中及高中学生提供一个交互式的数学学习与练习平台。系统完全通过图形化界面（UI）进行操作，涵盖了从用户注册、登录、密码管理到生成个性化试卷、在线答题和自动评分的全过程。项目严格遵循无数据库要求，所有用户数据和生成的试卷均通过本地文件进行存储和管理。
+
+
+
+## 二、项目目录结构
+
+
+
+```
+partner_project/
+├── .gitignore               # Git忽略配置文件，用于排除IDE配置和编译产物
+├── pom.xml                  # Maven配置文件 (如果使用Maven)
+├── src/                     # 源代码目录
+│   ├── auth/                # 用户认证与管理模块
+│   │   ├── User.java
+│   │   └── AuthService.java
+│   ├── generator/           # 题目生成模块
+│   │   ├── Problem.java
+│   │   ├── ProblemGenerator.java
+│   │   ├── PrimaryGenerator.java
+│   │   ├── MiddleGenerator.java
+│   │   └── HighGenerator.java
+│   ├── service/             # 业务逻辑服务模块
+│   │   └── ExamService.java
+│   ├── ui/                  # JavaFX界面控制器模块
+│   │   ├── MainApplication.java
+│   │   ├── LoginController.java
+│   │   ├── RegisterController.java
+│   │   ├── ModifyPasswordController.java
+│   │   └── ExamController.java
+│   ├── util/                # 工具类模块
+│   │   ├── EmailService.java
+│   │   ├── ExpressionUtils.java
+│   │   ├── FileUtils.java
+│   │   └── ModifyUtils.java
+│   └── Main.java            # 主程序入口
+└── resources/               # 资源文件目录
+    ├── fxml/                # FXML界面布局文件
+    │   ├── Login.fxml
+    │   ├── register-email.fxml
+    │   └── ...
+    ├── images/              # 存放应用的图片资源
+    │   ├── logo.png
+    │   └── background.png
+    └── styles/              # CSS样式文件
+        └── style.css
+```
+
+
+
+## 三、核心功能
+
+
+
+1. **用户管理模块**
+
+   - **邮箱注册**: 新用户需通过邮箱接收验证码以完成注册 。
+
+   - **登录与密码**: 用户使用用户名（或邮箱）和密码登录。密码长度为6-10位，且必须包含大小写字母和数字 2。
+
+   - **密码修改**: 用户在登录状态下，可通过验证旧密码来设置新密码 。
+
+     
+
+2. **试卷生成与答题模块**
+
+   - **难度选择**: 用户登录后可选择“小学”、“初中”、“高中”三种难度级别 。
+
+   - **个性化试卷**: 用户可指定生成的题目数量 5。系统确保同一张试卷内的题目不会重复，且题目均以选择题形式呈现 6。
+
+   - **在线答题**: 界面逐一展示题目及其选项，用户选择答案后进入下一题，直至完成所有题目 。
+
+     
+
+3. **评分与反馈模块**
+
+   - **自动评分**: 完成答题后，系统会根据用户的答题正确率自动计算并显示最终得分 。
+
+   - **流程选择**: 在分数界面，用户可以选择继续做题（返回难度选择界面）或退出程序 。
+
+     
+
+
+
+## 四、主要包结构与核心类介绍
+
+
+
+
+
+### (一) 主要包结构
+
+
+
+- `auth`: 负责用户认证与管理，包括用户信息的读取、验证、注册和修改。
+- `generator`: 负责数学题目的生成逻辑，定义了题目生成的标准接口和针对不同难度的具体实现。
+- `service`: 封装核心业务逻辑，协调 `auth` 和 `generator` 包，提供生成试卷、计算分数等服务。
+- `ui`: 包含所有 JavaFX 的界面控制器，负责处理用户交互和界面跳转。
+- `util`: 提供项目所需的通用工具类，如文件操作、邮件发送和表达式计算等。
+- `resources/fxml`: 存放所有界面的 FXML 布局文件。
+
+
+
+### (二) 核心类介绍
+
+
+
+
+
+#### 1. 认证与数据模块 (`auth`)
+
+
+
+- `User.java`: 用户数据模型，用于封装用户的基本信息，如用户名、密码、学习阶段和邮箱。
+- `AuthService.java`: 用户服务核心类。负责处理所有与用户相关的操作，包括登录验证、新用户注册、检查用户名或邮箱是否被占用、以及更新密码和用户难度等级。
+
+
+
+#### 2. 题目生成模块 (`generator`)
+
+
+
+- `Problem.java`: 题目数据模型，封装了一道题目的所有信息，包括题干表达式、四个选项、正确答案和计算结果。
+- `ProblemGenerator.java`: **题目生成器接口**，定义了 `generateProblems(int count)` 的标准方法，确保所有生成器都具有统一的行为。
+- `PrimaryGenerator.java`, `MiddleGenerator.java`, `HighGenerator.java`: `ProblemGenerator` 接口的具体实现类，分别用于生成小学、初中和高中难度的数学题目。
+
+
+
+#### 3. 业务服务模块 (`service`)
+
+
+
+- `ExamService.java`: 考试服务类。它是业务逻辑的中心，负责调用 `ProblemGenerator` 生成指定数量且不重复的试卷，并根据用户的答案计算最终得分。
+
+
+
+#### 4. 界面控制模块 (`ui`)
+
+
+
+- `MainApplication.java`: JavaFX 应用的入口，负责加载初始界面 (Login.fxml) 并启动窗口。
+- `LoginController.java`: 控制登录、跳转注册和修改密码界面的逻辑。
+- `RegisterController.java`: 控制用户注册的全过程，包括发送验证码、验证、设置用户名和密码等多个步骤。
+- `ExamController.java`: 最核心的界面控制器，负责处理难度选择、试卷生成、题目展示、答案提交、界面跳转以及最终分数展示的所有逻辑。
+
+
+
+#### 5. 工具类模块 (`util`)
+
+
+
+- `ExpressionUtils.java`: 表达式工具类，提供了计算字符串表达式结果、生成干扰选项等核心数学计算功能。
+- `FileUtils.java`: 文件操作工具类，封装了对用户历史题目文件的读取和新试卷的保存功能，是实现题目去重的基础。
+- `EmailService.java`: 邮件服务类，负责生成验证码并通过 SMTP 服务器发送邮件给注册用户。
+- `ModifyUtils.java`: 一个通用的文件修改工具，用于根据用户名精确地修改 `user.txt` 文件中特定字段（如密码或难度）。
+
+
+
+## 五、数据存储
+
+
+
+- **用户信息**: 存储在项目根目录下的 `user.txt` 文件中，每行代表一个用户，格式为：`用户名 密码 学习阶段 邮箱`。
+- **用户试卷**: 每个用户生成的试卷和答题历史都保存在 `exams/` 目录下以其用户名命名的子文件夹中，用于实现题目去重功能。
+
+
+
+## 六、题目特点
+
+
+
+- **小学难度**: 包含2到5个操作数的加、减、乘、除运算，并随机引入括号以增加复杂性。确保答案为非负整数。
+- **初中难度**: 在小学基础上，增加了平方(`^2`)和开平方根(`sqrt()`)运算。
+- **高中难度**: 在初中基础上，引入了三角函数 (`sin`, `cos`, `tan`) 运算。
+
+
+
+## 七、使用流程
+
+
+
+1. 启动 `Main.java` 中的 `MainApplication`，应用显示登录界面。
+
+2. **首次使用**: 点击“注册账户”按钮，通过邮箱验证流程创建新账户并设置密码 。
+
+3. **登录**: 输入用户名/邮箱和密码进行登录。
+
+4. **难度与数量选择**: 登录成功后，进入难度选择界面。选择一个学段（小学/初中/高中），并输入希望生成的题目数量（10-30） 。
+
+5. **开始答题**: 点击“生成试卷”按钮，系统会加载并显示第一道题。依次回答所有题目 。
+
+6. **查看分数**: 完成最后一题后，界面跳转至分数展示页面 。
+
+7. **后续操作**: 在分数页面，可选择“继续做题”返回难度选择界面，或选择“退出登录”、“退出程序” 。
+
+   
+
+   

src/util/ExpressionUtils.java

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

src/util/ModifyUtils.java

@@ -31,8 +31,9 @@ public class ModifyUtils {
     private static int findTargetLine(List<String> lines, String targetName) {
         for (int i = 0; i < lines.size(); i++) {
             String line = lines.get(i).trim();
-            if (line.isEmpty()) continue;
+            if (line.isEmpty()) {
-
+              continue;
+            }
             String[] parts = line.split("\\s+");
             if (parts.length > 0 && parts[0].equals(targetName)) {
                 return i; // 0-based index