From a9955059c1814163935155344a88f2b29e6b1fa3 Mon Sep 17 00:00:00 2001 From: hnu202326010305 <1405671544@qq.com> Date: Sun, 28 Sep 2025 21:37:57 +0800 Subject: [PATCH 1/5] Update BracketManager.java --- src/BracketManager.java | 495 ++++++++++++++++++++++++++++------------ 1 file changed, 347 insertions(+), 148 deletions(-) diff --git a/src/BracketManager.java b/src/BracketManager.java index ce53f57..add3be1 100644 --- a/src/BracketManager.java +++ b/src/BracketManager.java @@ -1,148 +1,347 @@ -import java.util.List; -import java.util.Random; - -/** - * 负责生成并添加括号 - */ -public class BracketManager { - private static final Random RANDOM = new Random(); - - /** - * 根据元素个数选择括号对数 - * 3 -> 80% 1对 20%0对 - * 4 -> 90% 1对 10%2对 - * 5 -> 50% 1对 50%2对 - */ - public int decideParenthesesPairs(int numCount) { - return switch (numCount) { - case 3 -> RANDOM.nextDouble() < 0.8 ? 1 : 0; - case 4 -> RANDOM.nextDouble() < 0.9 ? 1 : 2; - case 5 -> RANDOM.nextDouble() < 0.5 ? 1 : 2; - default -> 0; - }; - } - - // 添加括号 - public String addParentheses(String expression, int pairs, List numPositions) { - String[] tokens = expression.split(" "); - int numCount = numPositions.size(); - 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; - } - - //计算生成括号的位置 - private void generateBracketPositions(int numCount, List 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; - - // 20%概率尝试嵌套在已有括号内部 - if (RANDOM.nextDouble() < 0.2) { - for (int i = 0; i < numCount; i++) { - if (markLeft[i]) { - start = i; - end = i + RANDOM.nextInt(numCount - i); - break; - } - } - } - - if (canPlaceBracket(start, end, markLeft, markRight, numPositions, tokens)) { - markLeft[start] = true; - markRight[end] = true; - placed = true; - } - } - } - } - - //检测添加括号的合法性 - private boolean canPlaceBracket(int start, int end, boolean[] markLeft, boolean[] markRight, - List numPositions, String[] tokens) { - 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; - } - return false; - } - - //检测括号是否有意义（优先级） - private boolean isValidBracketRange(String[] tokens, List 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; - } - } - } - return hasHigherOuterOp || firstOp == null; - } - - //比较运算符优先级 - 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 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("( "); - sb.append(token); - if (markRight[numIndex]) sb.append(" )"); - numIndex++; - } else { - sb.append(" ").append(token).append(" "); - } - } - 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; - } - return balance == 0; - } - - private boolean isNumber(String token) { - try { Integer.parseInt(token); return true; } - catch (NumberFormatException e) { return false; } - } -} +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +/** + * 括号管理器 + */ +public class BracketManager { + private static final Random RANDOM = new Random(); + + /** + * 根据元素个数选择括号对数 + * 3 -> 80% 1对 20%0对 + * 4 -> 90% 1对 10%2对 + * 5 -> 50% 1对 50%2对 + */ + private int decideParenthesesPairs(int numCount) { + return switch (numCount) { + 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 addNestedParentheses(String expression) { + List 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 numPositions = getNumPositions(expression); + List innerRanges = getInnerBracketRanges(expression); + + // 找到未被第一层括号覆盖的段落 + List 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 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 innerRanges = getInnerBracketRanges(expression); + for (int[] range : innerRanges) { + String innerExpr = extractTokens(result, range[0], range[1]); + List 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 numPositions) { + String[] tokens = expression.split(" "); // 按空格拆分 + int numCount = numPositions.size(); + 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; // 验证括号匹配，非法返回原表达式 + } + + // 生成括号位置 + private void generateBracketPositions(int numCount, List 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; + } + + // 40%概率尝试嵌套在已有括号内部 + if (RANDOM.nextDouble() < 0.4) { + for (int i = 0; i < numCount; i++) { + if (markLeft[i]) { + start = i; + end = i + RANDOM.nextInt(numCount - i); + break; + } + } + } + + // 检查是否合法 + if (canPlaceBracket(start, end, markLeft, markRight, numPositions, tokens)) { + markLeft[start] = true; + markRight[end] = true; + placed = true; + } + } + } + } + + // 检查括号是否可以放置 + private boolean canPlaceBracket(int start, int end, boolean[] markLeft, boolean[] markRight, + List numPositions, String[] tokens) { + 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++) { + if ((i != start && markLeft[i]) || (i != end && markRight[i])) { + return true; + } + } + return false; + } + + // 检查括号区间内部最小优先级是否小于相邻外部运算符优先级 + private boolean isValidBracketRange(String[] tokens, List numPositions, int start, int end) { + int opStart = numPositions.get(start) + 1; + int opEnd = numPositions.get(end) - 1; + + // 找到括号内部最低优先级运算符 + 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 (leftPri != -1 && minPriInside < leftPri) || (rightPri != -1 && minPriInside < rightPri); + } + + // 获取相邻运算符优先级 + 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("(").append(" "); + } + sb.append(token); + if (markRight[numIndex]) { + sb.append(" ").append(")"); + } + numIndex++; + } else { + sb.append(" ").append(token).append(" "); + } + } + 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; + } + } + return balance == 0; + } + + // 判断是否为数字 + private boolean isNumber(String token) { + try { + Integer.parseInt(token); + return true; + } catch (NumberFormatException e) { + return false; + } + } + + // 获取表达式中数字位置 + private List getNumPositions(String expr) { + String[] tokens = expr.split(" "); + List positions = new ArrayList<>(); + for (int i = 0; i < tokens.length; i++) { + if (isNumber(tokens[i])) { + positions.add(i); + } + } + return positions; + } + + // 获取第一层括号内部 token 范围 + private List getInnerBracketRanges(String expr) { + List 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(); + } + +} -- 2.34.1 From 6847ce95661ad11781a3a9e5f2c1b98b3aec7a64 Mon Sep 17 00:00:00 2001 From: hnu202326010305 <1405671544@qq.com> Date: Sun, 28 Sep 2025 21:38:23 +0800 Subject: [PATCH 2/5] Update ExamSystem.java --- src/ExamSystem.java | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/ExamSystem.java b/src/ExamSystem.java index c87489a..e500435 100644 --- a/src/ExamSystem.java +++ b/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]); -- 2.34.1 From 3faec770ef043dc1628b4be932bc01bc23dfb2bc Mon Sep 17 00:00:00 2001 From: hnu202326010305 <1405671544@qq.com> Date: Sun, 28 Sep 2025 21:39:41 +0800 Subject: [PATCH 3/5] Update JuniorProblem.java --- src/JuniorProblem.java | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/src/JuniorProblem.java b/src/JuniorProblem.java index c7fad26..a3fa78a 100644 --- a/src/JuniorProblem.java +++ b/src/JuniorProblem.java @@ -17,18 +17,13 @@ public class JuniorProblem implements ProblemsGenerator { do { int numCount = RANDOM.nextInt(5) + 1; expression = expressionBuilder.generateBasicExpression(numCount); - List 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 numPositions = expressionBuilder.getNumberPositions(expression); + expression = powerManager.addPowerOperations(expression, numPositions, null); hasPower = expression.contains("^2") || expression.contains("√"); + } while (expressionBuilder.hasDivideByZero(expression) || !hasPower); return expression; -- 2.34.1 From 4d57401f20587f757dcfd845dc9f8657ec20aae4 Mon Sep 17 00:00:00 2001 From: hnu202326010305 <1405671544@qq.com> Date: Sun, 28 Sep 2025 21:40:03 +0800 Subject: [PATCH 4/5] Update PowerManager.java --- src/PowerManager.java | 243 +++++++++++++++++++++++++----------------- 1 file changed, 148 insertions(+), 95 deletions(-) diff --git a/src/PowerManager.java b/src/PowerManager.java index b3ba370..f4c7295 100644 --- a/src/PowerManager.java +++ b/src/PowerManager.java @@ -1,95 +1,148 @@ -import java.util.List; -import java.util.Random; - -/** - * 负责添加幂运算 - */ -public class PowerManager { - private static final Random RANDOM = new Random(); - - // 普通幂运算 - public String addPowerOperations(String expression, List numPositions) { - 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); - } - - return String.join(" ", tokens); - } - - // 避免加在 trig 已占用的位置，同时避免加在运算符右边 - public String addPowerOperationsAvoid(String expression, List numPositions, List trigPositions) { - if (numPositions.isEmpty()) return expression; - - String[] tokens = expression.split(" "); - int targetIndex = chooseTargetIndex(tokens, numPositions, trigPositions); - - if (targetIndex != -1) { - tokens[targetIndex] = applyPower(tokens[targetIndex], tokens, targetIndex); - } - - return String.join(" ", tokens); - } - - // 选择合适的位置加幂运算 - private int chooseTargetIndex(String[] tokens, List numPositions, List avoidPositions) { - for (int tries = 0; tries < 20; tries++) { - int idx = numPositions.get(RANDOM.nextInt(numPositions.size())); - - if ((avoidPositions == null || !avoidPositions.contains(idx)) && canApplyPower(tokens, idx)) { - return idx; - } - } - return -1; - } - - // 检查该位置是否可以加幂运算 - private boolean canApplyPower(String[] tokens, int index) { - if (!isNumber(tokens[index])) return false; - if (tokens[index].contains("^") || tokens[index].contains("√")) return false; // 避免重复幂运算 - - // 不能加在运算符右边 - if (index > 0) { - String prev = tokens[index - 1]; - if (prev.equals("/") || prev.equals("*") || prev.equals("+") || prev.equals("-")) { - return false; - } - } - return true; - } - - // 应用平方或开方（根号放左括号左侧，平方放右括号右侧） - private String applyPower(String token, String[] tokens, int index) { - boolean useSqrt = RANDOM.nextBoolean(); - - if (useSqrt) { - // 根号放在左括号左侧，如果前面是左括号，则放在括号左边 - if (index > 0 && tokens[index - 1].equals(")")) { - return "√" + token; // 特殊情况，仍然放数字前 - } - 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"; - } - } - - private boolean isNumber(String token) { - try { - Integer.parseInt(token); - return true; - } catch (NumberFormatException e) { - return false; - } - } -} +import java.util.List; +import java.util.ArrayList; +import java.util.Random; + +public class PowerManager { + private static final Random RANDOM = new Random(); + + //添加一次幂运算,30%概率再加一次 + public String addPowerOperations(String expression, List numPositions, + List trigPositions) { + if (numPositions.isEmpty()) { + return expression; + } + + String[] tokens = expression.split(" "); + + addOnePower(tokens, numPositions, trigPositions); + if (RANDOM.nextDouble() < 0.3) { + addOnePower(tokens, numPositions, trigPositions); + } + + return String.join(" ", tokens); + } + + // 添加一次幂运算，平方/根号各50% + private void addOnePower(String[] tokens, List numPositions, List trigPositions) { + if (RANDOM.nextBoolean()) { + tryAddSquare(tokens, numPositions, trigPositions); + } else { + tryAddSqrt(tokens, numPositions, trigPositions); + } + } + + // 添加平方 + private void tryAddSquare(String[] tokens, List numPositions, + List trigPositions) { + int target = chooseTargetIndex(tokens, numPositions, trigPositions, true); + if (target != -1) { + tokens[target] = tokens[target] + "^2"; + } + } + + // 添加根号 + private void tryAddSqrt(String[] tokens, List numPositions, + List trigPositions) { + int target = chooseTargetIndex(tokens, numPositions, trigPositions, false); + if (target != -1) { + tokens[target] = "√" + tokens[target]; + } + } + + // 选择可插入位置 + private int chooseTargetIndex(String[] tokens, List numPositions, + List trigPositions, boolean isSquare) { + List candidates = new ArrayList<>(); + for (int idx : numPositions) { + String token = tokens[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 checkParenCanAdd(String[] tokens, int index, boolean isSquare) { + int match = findMatchingParen(tokens, index); + if (match == -1) { + return false; + } + + // 检查匹配括号是否已加运算 + if (tokens[match].contains("^") || tokens[match].contains("√")) { + return false; + } + + // 左括号只能加根号，右括号只能加平方 + if (isSquare && tokens[index].equals("(")) { + return false; + } + return isSquare || !tokens[index].equals(")"); + } + + // 找匹配括号 + 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; + } + } + } + } 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 { + Integer.parseInt(token); + return true; + } catch (NumberFormatException e) { + return false; + } + } +} -- 2.34.1 From 278e7f61a4953eb1222726423cca578792e858a0 Mon Sep 17 00:00:00 2001 From: hnu202326010305 <1405671544@qq.com> Date: Sun, 28 Sep 2025 21:40:25 +0800 Subject: [PATCH 5/5] Update SeniorProblem.java --- src/SeniorProblem.java | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/src/SeniorProblem.java b/src/SeniorProblem.java index fe22fe5..8b6f9e2 100644 --- a/src/SeniorProblem.java +++ b/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 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 numPositions = expressionBuilder.getNumberPositions(expression); - // 添加三角函数并检查是否存在 + // 添加三角函数并重新获取数字位置 expression = trigManager.addTrigOperations(expression, numPositions); - List trigPositions = expressionBuilder.getNumberPositions(expression); - hasTrig = expression.contains("sin") || expression.contains("cos") || expression.contains("tan"); + List 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; -- 2.34.1