Merge pull request '4' (#4) from develop into main

src/BracketManager.java

@@ -1,8 +1,9 @@
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 
 /**
- * 负责生成并添加括号
+ * 括号管理器
  */
 public class BracketManager {
   private static final Random RANDOM = new Random();
@@ -13,40 +14,114 @@ public class BracketManager {
    * 4 -> 90% 1对 10%2对
    * 5 -> 50% 1对 50%2对
    */
-  public int decideParenthesesPairs(int numCount) {
+  private int decideParenthesesPairs(int numCount) {
     return switch (numCount) {
-      case 3 -> RANDOM.nextDouble() < 0.8 ? 1 : 0;
-      case 4 -> RANDOM.nextDouble() < 0.9 ? 1 : 2;
+      case 3 -> RANDOM.nextDouble() < 0.6 ? 1 : 0;
+      case 4 -> RANDOM.nextDouble() < 0.8 ? 1 : 2;
       case 5 -> RANDOM.nextDouble() < 0.5 ? 1 : 2;
       default -> 0;
     };
   }
   
   // 添加括号
-  public String addParentheses(String expression, int pairs, List<Integer> numPositions) {
-    String[] tokens = expression.split(" ");
+  public String addNestedParentheses(String expression) {
+    List<Integer> numPositions = getNumPositions(expression);
+    int pairs = decideParenthesesPairs(numPositions.size());
+    
+    String result;
+    if (pairs == 1) {
+      result = addParentheses(expression, 1, numPositions);
+    } else if (pairs == 2) {
+      String first = addParentheses(expression, 1, numPositions);
+      String second = addParallelOutside(first);
+      if (!second.equals(first)) {
+        result = second;
+      } else {
+        result = addNestedInside(first);
+      }
+    } else {
+      result = expression;
+    }
+    
+    result = fixLeftParenthesisSpacing(result);
+    return result;
+  }
+  
+  // 并列括号
+  private String addParallelOutside(String expression) {
+    String result = expression;
+    List<Integer> numPositions = getNumPositions(expression);
+    List<int[]> innerRanges = getInnerBracketRanges(expression);
+    
+    // 找到未被第一层括号覆盖的段落
+    List<int[]> outerRanges = new ArrayList<>();
+    int lastEnd = -1;
+    for (int[] range : innerRanges) {
+      if (range[0] - 1 > lastEnd + 1) {
+        outerRanges.add(new int[]{lastEnd + 1, range[0] - 1});
+      }
+      lastEnd = range[1];
+    }
+    if (lastEnd + 1 < numPositions.size()) {
+      outerRanges.add(new int[]{lastEnd + 1, numPositions.size() - 1});
+    }
+    
+    boolean added = false;
+    for (int[] range : outerRanges) {
+      String outerExpr = extractTokens(result, range[0], range[1]);
+      List<Integer> outerNumPos = getNumPositions(outerExpr);
+      int outerPairs = decideParenthesesPairs(outerNumPos.size());
+      if (outerPairs > 0) {
+        String newOuterExpr = addParentheses(outerExpr, outerPairs, outerNumPos);
+        result = replaceTokens(result, range[0], range[1], newOuterExpr);
+        added = true;
+      }
+    }
+    
+    return added ? result : expression;
+  }
+  
+  // 嵌套括号
+  private String addNestedInside(String expression) {
+    String result = expression;
+    List<int[]> innerRanges = getInnerBracketRanges(expression);
+    for (int[] range : innerRanges) {
+      String innerExpr = extractTokens(result, range[0], range[1]);
+      List<Integer> innerNumPos = getNumPositions(innerExpr);
+      int innerPairs = decideParenthesesPairs(innerNumPos.size());
+      String newInnerExpr = addParentheses(innerExpr, innerPairs, innerNumPos);
+      result = replaceTokens(result, range[0], range[1], newInnerExpr);
+    }
+    return result;
+  }
+  
+  // 添加括号核心逻辑
+  private String addParentheses(String expression, int pairs, List<Integer> numPositions) {
+    String[] tokens = expression.split(" "); // 按空格拆分
     int numCount = numPositions.size();
-    boolean[] markLeft = new boolean[numCount];
-    boolean[] markRight = new boolean[numCount];
+    boolean[] markLeft = new boolean[numCount]; // 左括号标记
+    boolean[] markRight = new boolean[numCount]; // 右括号标记
     
-    generateBracketPositions(numCount, numPositions, pairs, tokens, markLeft, markRight);
-    String result = insertBrackets(tokens, markLeft, markRight);
-    return validateParentheses(result) ? result : expression;
+    generateBracketPositions(numCount, numPositions, pairs, tokens, markLeft, markRight); // 生成括号位置
+    String result = insertBrackets(tokens, markLeft, markRight); // 插入括号
+    return validateParentheses(result) ? result : expression; // 验证括号匹配，非法返回原表达式
   }
   
-  //计算生成括号的位置
+  // 生成括号位置
   private void generateBracketPositions(int numCount, List<Integer> numPositions, int pairs, String[] tokens,
                                         boolean[] markLeft, boolean[] markRight) {
     int attempts = 0;
     for (int p = 0; p < pairs && attempts < 50; p++, attempts++) {
       boolean placed = false;
       for (int tries = 0; tries < 50 && !placed; tries++) {
-        int start = RANDOM.nextInt(numCount - 1);
-        int end = start + 1 + RANDOM.nextInt(numCount - start - 1);
-        if (end >= numCount) end = numCount - 1;
+        int start = RANDOM.nextInt(numCount - 1); // 随机起始数字索引
+        int end = start + 1 + RANDOM.nextInt(numCount - start - 1); // 随机结束数字索引
+        if (end >= numCount) {
+          end = numCount - 1;
+        }
         
-        // 20%概率尝试嵌套在已有括号内部
-        if (RANDOM.nextDouble() < 0.2) {
+        // 40%概率尝试嵌套在已有括号内部
+        if (RANDOM.nextDouble() < 0.4) {
           for (int i = 0; i < numCount; i++) {
             if (markLeft[i]) {
               start = i;
@@ -56,6 +131,7 @@ public class BracketManager {
           }
         }
         
+        // 检查是否合法
         if (canPlaceBracket(start, end, markLeft, markRight, numPositions, tokens)) {
           markLeft[start] = true;
           markRight[end] = true;
@@ -65,63 +141,96 @@ public class BracketManager {
     }
   }
   
-  //检测添加括号的合法性
+  // 检查括号是否可以放置
   private boolean canPlaceBracket(int start, int end, boolean[] markLeft, boolean[] markRight,
                                   List<Integer> numPositions, String[] tokens) {
-    if (isOuterMostBracket(start, end, markLeft.length)) return false;
-    if (isInvalidOverlap(start, end, markLeft, markRight)) return false;
+    if (isOuterMostBracket(start, end, markLeft.length)) {
+      return false;
+    }
+    if (isInvalidOverlap(start, end, markLeft, markRight)) {
+      return false;
+    }
     return isValidBracketRange(tokens, numPositions, start, end);
   }
   
-  //避免最外层括号
+  // 避免最外层括号
   private boolean isOuterMostBracket(int start, int end, int numCount) {
     return start == 0 && end == numCount - 1;
   }
   
-  //允许嵌套但禁止交叉
+  // 避免交叉括号，允许嵌套
   private boolean isInvalidOverlap(int start, int end, boolean[] markLeft, boolean[] markRight) {
     for (int i = start; i <= end; i++) {
-      // start/end可重合，内部禁止已有左右括号
-      if ((i != start && markLeft[i]) || (i != end && markRight[i])) return true;
+      if ((i != start && markLeft[i]) || (i != end && markRight[i])) {
+        return true;
+      }
     }
     return false;
   }
   
-  //检测括号是否有意义（优先级）
+  // 检查括号区间内部最小优先级是否小于相邻外部运算符优先级
   private boolean isValidBracketRange(String[] tokens, List<Integer> numPositions, int start, int end) {
     int opStart = numPositions.get(start) + 1;
     int opEnd = numPositions.get(end) - 1;
-    String firstOp = null;
-    boolean hasHigherOuterOp = false;
-    
-    for (int i = opStart; i <= opEnd; i += 2) {
-      if (!isNumber(tokens[i])) {
-        if (firstOp == null) firstOp = tokens[i];
-        else if (isDifferentPriority(firstOp, tokens[i])) {
-          hasHigherOuterOp = true;
-          break;
+    
+    // 找到括号内部最低优先级运算符
+    int minPriInside = Integer.MAX_VALUE;
+    for (int i = opStart; i <= opEnd; i++) {
+      if (i < 0 || i >= tokens.length) {
+        continue;
+      }
+      String t = tokens[i];
+      if (t.equals("(") || t.equals(")")) {
+        continue;
+      }
+      if (!isNumber(t)) {
+        int p = getPrecedence(t);
+        if (p > 0) minPriInside = Math.min(minPriInside, p);
       }
     }
+    if (minPriInside == Integer.MAX_VALUE) {
+      return false;
+    }
+    
+    int leftPri = getAdjacentOpPrecedence(tokens, numPositions.get(start) - 1);
+    int rightPri = getAdjacentOpPrecedence(tokens, numPositions.get(end) + 1);
+    
+    if (leftPri == -1 && rightPri == -1) {
+      return false;
     }
-    return hasHigherOuterOp || firstOp == null;
+    return (leftPri != -1 && minPriInside < leftPri) || (rightPri != -1 && minPriInside < rightPri);
   }
   
-  //比较运算符优先级
-  private boolean isDifferentPriority(String op1, String op2) {
-    int p1 = (op1.equals("+") || op1.equals("-")) ? 1 : 2;
-    int p2 = (op2.equals("+") || op2.equals("-")) ? 1 : 2;
-    return p1 != p2;
+  // 获取相邻运算符优先级
+  private int getAdjacentOpPrecedence(String[] tokens, int idx) {
+    if (idx < 0 || idx >= tokens.length) return -1;
+    String t = tokens[idx];
+    if (t.equals("(") || t.equals(")") || isNumber(t)) return -1;
+    return getPrecedence(t);
   }
   
-  //插入操作
+  // 运算符优先级
+  private int getPrecedence(String op) {
+    return switch (op) {
+      case "+", "-" -> 1;
+      case "*", "/" -> 2;
+      default -> 0;
+    };
+  }
+  
+  // 插入括号
   private String insertBrackets(String[] tokens, boolean[] markLeft, boolean[] markRight) {
     StringBuilder sb = new StringBuilder();
     int numIndex = 0;
     for (String token : tokens) {
       if (isNumber(token)) {
-        if (markLeft[numIndex]) sb.append("( ");
+        if (markLeft[numIndex]) {
+          sb.append("(").append(" ");
+        }
         sb.append(token);
-        if (markRight[numIndex]) sb.append(" )");
+        if (markRight[numIndex]) {
+          sb.append(" ").append(")");
+        }
         numIndex++;
       } else {
         sb.append(" ").append(token).append(" ");
@@ -130,19 +239,109 @@ public class BracketManager {
     return sb.toString();
   }
   
-  //检查括号是否缺失
+  // 验证括号匹配
   private boolean validateParentheses(String expr) {
     int balance = 0;
     for (char c : expr.toCharArray()) {
-      if (c == '(') balance++;
-      if (c == ')') balance--;
-      if (balance < 0) return false;
+      if (c == '(') {
+        balance++;
+      }
+      if (c == ')') {
+        balance--;
+      }
+      if (balance < 0) {
+        return false;
+      }
     }
     return balance == 0;
   }
   
+  // 判断是否为数字
   private boolean isNumber(String token) {
-    try { Integer.parseInt(token); return true; }
-    catch (NumberFormatException e) { return false; }
+    try {
+      Integer.parseInt(token);
+      return true;
+    } catch (NumberFormatException e) {
+      return false;
+    }
+  }
+  
+  // 获取表达式中数字位置
+  private List<Integer> getNumPositions(String expr) {
+    String[] tokens = expr.split(" ");
+    List<Integer> positions = new ArrayList<>();
+    for (int i = 0; i < tokens.length; i++) {
+      if (isNumber(tokens[i])) {
+        positions.add(i);
+      }
+    }
+    return positions;
+  }
+  
+  // 获取第一层括号内部 token 范围
+  private List<int[]> getInnerBracketRanges(String expr) {
+    List<int[]> ranges = new ArrayList<>();
+    String[] tokens = expr.split(" ");
+    int balance = 0, start = -1;
+    for (int i = 0; i < tokens.length; i++) {
+      if (tokens[i].equals("(")) {
+        if (balance == 0) {
+          start = i;
+        }
+        balance++;
+      } else if (tokens[i].equals(")")) {
+        balance--;
+        if (balance == 0 && start != -1) {
+          ranges.add(new int[]{start + 1, i - 1});
+        }
+      }
+    }
+    return ranges;
+  }
+  
+  // 提取指定范围 token
+  private String extractTokens(String expr, int start, int end) {
+    String[] tokens = expr.split(" ");
+    StringBuilder sb = new StringBuilder();
+    for (int i = start; i <= end; i++) {
+      if (i > start) sb.append(" ");
+      sb.append(tokens[i]);
+    }
+    return sb.toString();
+  }
+  
+  // 替换指定范围 token
+  private String replaceTokens(String expr, int start, int end, String replacement) {
+    String[] tokens = expr.split(" ");
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < tokens.length; i++) {
+      if (i == start) {
+        sb.append(replacement);
+        i = end;
+      } else {
+        if (!sb.isEmpty()) {
+          sb.append(" ");
+        }
+        sb.append(tokens[i]);
+      }
     }
+    return sb.toString();
+  }
+  
+  //修正左括号后" "缺失
+  private String fixLeftParenthesisSpacing(String expr) {
+    StringBuilder sb = new StringBuilder();
+    char[] chars = expr.toCharArray();
+    for (int i = 0; i < chars.length; i++) {
+      char c = chars[i];
+      sb.append(c);
+      if (c == '(') {
+        if (i + 1 < chars.length && chars[i + 1] != ' ') {
+          sb.append(' ');
+        }
+      }
+    }
+    return sb.toString();
+  }
+  
 }

src/ExamSystem.java

@@ -1,16 +1,22 @@
+import java.nio.charset.StandardCharsets;
 import java.util.Scanner;
 
 /**
  * 系统界面
  */
 public class ExamSystem {
-  private final Scanner scanner = new Scanner(System.in);
+  private final Scanner scanner = new Scanner(System.in, StandardCharsets.UTF_8);
   
   public Users login() {
     Users users = null;
     while (users == null) {
       System.out.print("请输入用户名和密码: ");
       String input = scanner.nextLine();
+      if (input.equals("-1")) {
+        System.out.println("exit");
+        System.exit(0);
+      }
+      
       String[] parts = input.split(" ");
       if (parts.length == 2) {
         users = Users.login(parts[0], parts[1]);

src/JuniorProblem.java

@@ -17,18 +17,13 @@ public class JuniorProblem implements ProblemsGenerator {
     do {
       int numCount = RANDOM.nextInt(5) + 1;
       expression = expressionBuilder.generateBasicExpression(numCount);
-      List<Integer> numPositions = expressionBuilder.getNumberPositions(expression);
       
-      if (RANDOM.nextDouble() < 0.8) {
-        int pairs = bracketManager.decideParenthesesPairs(numCount);
-        if (pairs > 0) {
-          expression = bracketManager.addParentheses(expression, pairs, numPositions);
-        }
-      }
+      expression = bracketManager.addNestedParentheses(expression);
       
-      // 添加幂运算并检查添加是否成功
-      expression = powerManager.addPowerOperations(expression, numPositions);
+      List<Integer> numPositions = expressionBuilder.getNumberPositions(expression);
+      expression = powerManager.addPowerOperations(expression, numPositions, null);
       hasPower = expression.contains("^2") || expression.contains("√");
+      
     } while (expressionBuilder.hasDivideByZero(expression) || !hasPower);
     
     return expression;

src/PowerManager.java

@@ -1,88 +1,141 @@
 import java.util.List;
+import java.util.ArrayList;
 import java.util.Random;
 
-/**
- * 负责添加幂运算
- */
 public class PowerManager {
   private static final Random RANDOM = new Random();
   
-  // 普通幂运算
-  public String addPowerOperations(String expression, List<Integer> numPositions) {
-    if (numPositions.isEmpty()) return expression;
+  //添加一次幂运算,30%概率再加一次
+  public String addPowerOperations(String expression, List<Integer> numPositions,
+                                   List<Integer> trigPositions) {
+    if (numPositions.isEmpty()) {
+      return expression;
+    }
     
     String[] tokens = expression.split(" ");
-    int targetIndex = chooseTargetIndex(tokens, numPositions, null);
     
-    if (targetIndex != -1) {
-      tokens[targetIndex] = applyPower(tokens[targetIndex], tokens, targetIndex);
+    addOnePower(tokens, numPositions, trigPositions);
+    if (RANDOM.nextDouble() < 0.3) {
+      addOnePower(tokens, numPositions, trigPositions);
     }
     
     return String.join(" ", tokens);
   }
   
-  // 避免加在 trig 已占用的位置，同时避免加在运算符右边
-  public String addPowerOperationsAvoid(String expression, List<Integer> numPositions, List<Integer> trigPositions) {
-    if (numPositions.isEmpty()) return expression;
-    
-    String[] tokens = expression.split(" ");
-    int targetIndex = chooseTargetIndex(tokens, numPositions, trigPositions);
+  // 添加一次幂运算，平方/根号各50%
+  private void addOnePower(String[] tokens, List<Integer> numPositions, List<Integer> trigPositions) {
+    if (RANDOM.nextBoolean()) {
+      tryAddSquare(tokens, numPositions, trigPositions);
+    } else {
+      tryAddSqrt(tokens, numPositions, trigPositions);
+    }
+  }
   
-    if (targetIndex != -1) {
-      tokens[targetIndex] = applyPower(tokens[targetIndex], tokens, targetIndex);
+  // 添加平方
+  private void tryAddSquare(String[] tokens, List<Integer> numPositions,
+                            List<Integer> trigPositions) {
+    int target = chooseTargetIndex(tokens, numPositions, trigPositions, true);
+    if (target != -1) {
+      tokens[target] = tokens[target] + "^2";
+    }
   }
   
-    return String.join(" ", tokens);
+  // 添加根号
+  private void tryAddSqrt(String[] tokens, List<Integer> numPositions,
+                          List<Integer> trigPositions) {
+    int target = chooseTargetIndex(tokens, numPositions, trigPositions, false);
+    if (target != -1) {
+      tokens[target] = "√" + tokens[target];
+    }
   }
   
-  // 选择合适的位置加幂运算
-  private int chooseTargetIndex(String[] tokens, List<Integer> numPositions, List<Integer> avoidPositions) {
-    for (int tries = 0; tries < 20; tries++) {
-      int idx = numPositions.get(RANDOM.nextInt(numPositions.size()));
+  // 选择可插入位置
+  private int chooseTargetIndex(String[] tokens, List<Integer> numPositions,
+                                List<Integer> trigPositions, boolean isSquare) {
+    List<Integer> candidates = new ArrayList<>();
+    for (int idx : numPositions) {
+      String token = tokens[idx];
       
-      if ((avoidPositions == null || !avoidPositions.contains(idx)) && canApplyPower(tokens, idx)) {
-        return idx;
+      // 避免 trig 位置
+      if (trigPositions != null && trigPositions.contains(idx)) {
+        continue;
+      }
+      // 不能已有运算
+      if (token.contains("^") || token.contains("√")) {
+        continue;
+      }
+      // 括号匹配检查
+      if ((token.equals("(") || token.equals(")")) && !checkParenCanAdd(tokens, idx, isSquare)) {
+        continue;
+      }
+      
+      // 根号/平方合法性
+      if (isSquare) {
+        if (isNumber(token) || token.equals(")")) {
+          candidates.add(idx);
+        }
+      }
+      if (!isSquare) {
+        if (isNumber(token) || token.equals("(")) {
+          candidates.add(idx);
         }
       }
+    }
+    
+    if (candidates.isEmpty()) {
       return -1;
     }
+    return candidates.get(RANDOM.nextInt(candidates.size()));
+  }
   
-  // 检查该位置是否可以加幂运算
-  private boolean canApplyPower(String[] tokens, int index) {
-    if (!isNumber(tokens[index])) return false;
-    if (tokens[index].contains("^") || tokens[index].contains("√")) return false; // 避免重复幂运算
+  // 检查括号匹配另一侧是否可以加运算
+  private boolean checkParenCanAdd(String[] tokens, int index, boolean isSquare) {
+    int match = findMatchingParen(tokens, index);
+    if (match == -1) {
+      return false;
+    }
     
-    // 不能加在运算符右边
-    if (index > 0) {
-      String prev = tokens[index - 1];
-      if (prev.equals("/") || prev.equals("*") || prev.equals("+") || prev.equals("-")) {
+    // 检查匹配括号是否已加运算
+    if (tokens[match].contains("^") || tokens[match].contains("√")) {
       return false;
     }
+    
+    // 左括号只能加根号，右括号只能加平方
+    if (isSquare && tokens[index].equals("(")) {
+      return false;
     }
-    return true;
+    return isSquare || !tokens[index].equals(")");
   }
   
-  // 应用平方或开方（根号放左括号左侧，平方放右括号右侧）
-  private String applyPower(String token, String[] tokens, int index) {
-    boolean useSqrt = RANDOM.nextBoolean();
-    
-    if (useSqrt) {
-      // 根号放在左括号左侧，如果前面是左括号，则放在括号左边
-      if (index > 0 && tokens[index - 1].equals(")")) {
-        return "√" + token; // 特殊情况，仍然放数字前
+  // 找匹配括号
+  private int findMatchingParen(String[] tokens, int index) {
+    if (tokens[index].equals("(")) {
+      int depth = 0;
+      for (int i = index; i < tokens.length; i++) {
+        if (tokens[i].equals("(")) {
+          depth++;
+        } else if (tokens[i].equals(")")) {
+          depth--;
+          if (depth == 0) {
+            return i;
           }
-      if (index > 0 && tokens[index - 1].equals("(")) {
-        return "√" + token;
         }
-      return "√" + token;
-    } else {
-      // 平方放在右括号右侧，如果后面是右括号，则放在括号右边
-      if (index < tokens.length - 1 && tokens[index + 1].equals(")")) {
-        return token + "^2";
       }
-      return token + "^2";
+    } else if (tokens[index].equals(")")) {
+      int depth = 0;
+      for (int i = index; i >= 0; i--) {
+        if (tokens[i].equals(")")) {
+          depth++;
+        } else if (tokens[i].equals("(")) {
+          depth--;
+          if (depth == 0) {
+            return i;
+          }
         }
       }
+    }
+    return -1;
+  }
   
   private boolean isNumber(String token) {
     try {

src/SeniorProblem.java

@@ -15,27 +15,27 @@ public class SeniorProblem implements ProblemsGenerator {
   public String generate() {
     String expression;
     boolean hasTrig;
+    
     do {
+      // 生成基础表达式并添加括号
       int numCount = RANDOM.nextInt(5) + 1;
       expression = expressionBuilder.generateBasicExpression(numCount);
-      List<Integer> numPositions = expressionBuilder.getNumberPositions(expression);
+      expression = bracketManager.addNestedParentheses(expression);
       
-      if (RANDOM.nextDouble() < 0.8) {
-        int pairs = bracketManager.decideParenthesesPairs(numCount);
-        if (pairs > 0) {
-          expression = bracketManager.addParentheses(expression, pairs, numPositions);
-        }
-      }
+      // 获取初始数字位置
+      List<Integer> numPositions = expressionBuilder.getNumberPositions(expression);
       
-      // 添加三角函数并检查是否存在
+      // 添加三角函数并重新获取数字位置
       expression = trigManager.addTrigOperations(expression, numPositions);
-      List<Integer> trigPositions = expressionBuilder.getNumberPositions(expression);
-      hasTrig = expression.contains("sin") || expression.contains("cos") || expression.contains("tan");
+      List<Integer> numPositionsAfterTrig = expressionBuilder.getNumberPositions(expression);
       
-      // 40% 概率加幂运算，避免与 trig 重叠
-      if (RANDOM.nextDouble() < 0.4) {
-        expression = powerManager.addPowerOperationsAvoid(expression, numPositions, trigPositions);
+      // 判断是否包含三角函数
+      hasTrig = expression.contains("sin") || expression.contains("cos") || expression.contains("tan");
+      // 添加幂运算，50%概率执行
+      if (RANDOM.nextDouble() < 0.5) {
+        expression = powerManager.addPowerOperations(expression, numPositionsAfterTrig, null);
       }
+      
     } while (expressionBuilder.hasDivideByZero(expression) || !hasTrig);
     
     return expression;