hnu202326010305
/
Problem_Generator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update BracketManager.java

Browse Source
pull/4/head
hnu202326010305 1 week ago
parent ccf30dd651
commit a9955059c1
1 changed files with 347 additions and 148 deletions
Show Stats Download Patch File Download Diff File

495
src/BracketManager.java
Unescape View File

@ -1,148 +1,347 @@
import java.util.List; import java.util.ArrayList;
import java.util.Random; import java.util.List;
import java.util.Random;
/**
* 负责生成并添加括号 /**
*/ * 括号管理器
public class BracketManager { */
private static final Random RANDOM = new Random(); public class BracketManager {
private static final Random RANDOM = new Random();
/**
* 根据元素个数选择括号对数 /**
* 3 -> 80% 1对 20%0对 * 根据元素个数选择括号对数
* 4 -> 90% 1对 10%2对 * 3 -> 80% 1对 20%0对
* 5 -> 50% 1对 50%2对 * 4 -> 90% 1对 10%2对
*/ * 5 -> 50% 1对 50%2对
public int decideParenthesesPairs(int numCount) { */
return switch (numCount) { private int decideParenthesesPairs(int numCount) {
case 3 -> RANDOM.nextDouble() < 0.8 ? 1 : 0; return switch (numCount) {
case 4 -> RANDOM.nextDouble() < 0.9 ? 1 : 2; case 3 -> RANDOM.nextDouble() < 0.6 ? 1 : 0;
case 5 -> RANDOM.nextDouble() < 0.5 ? 1 : 2; case 4 -> RANDOM.nextDouble() < 0.8 ? 1 : 2;
default -> 0; 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) {
int numCount = numPositions.size(); List<Integer> numPositions = getNumPositions(expression);
boolean[] markLeft = new boolean[numCount]; int pairs = decideParenthesesPairs(numPositions.size());
boolean[] markRight = new boolean[numCount];
String result;
generateBracketPositions(numCount, numPositions, pairs, tokens, markLeft, markRight); if (pairs == 1) {
String result = insertBrackets(tokens, markLeft, markRight); result = addParentheses(expression, 1, numPositions);
return validateParentheses(result) ? result : expression; } else if (pairs == 2) {
} String first = addParentheses(expression, 1, numPositions);
String second = addParallelOutside(first);
//计算生成括号的位置 if (!second.equals(first)) {
private void generateBracketPositions(int numCount, List<Integer> numPositions, int pairs, String[] tokens, result = second;
boolean[] markLeft, boolean[] markRight) { } else {
int attempts = 0; result = addNestedInside(first);
for (int p = 0; p < pairs && attempts < 50; p++, attempts++) { }
boolean placed = false; } else {
for (int tries = 0; tries < 50 && !placed; tries++) { result = expression;
int start = RANDOM.nextInt(numCount - 1); }
int end = start + 1 + RANDOM.nextInt(numCount - start - 1);
if (end >= numCount) end = numCount - 1; result = fixLeftParenthesisSpacing(result);
return result;
// 20%概率尝试嵌套在已有括号内部 }
if (RANDOM.nextDouble() < 0.2) {
for (int i = 0; i < numCount; i++) { // 并列括号
if (markLeft[i]) { private String addParallelOutside(String expression) {
start = i; String result = expression;
end = i + RANDOM.nextInt(numCount - i); List<Integer> numPositions = getNumPositions(expression);
break; List<int[]> innerRanges = getInnerBracketRanges(expression);
}
} // 找到未被第一层括号覆盖的段落
} List<int[]> outerRanges = new ArrayList<>();
int lastEnd = -1;
if (canPlaceBracket(start, end, markLeft, markRight, numPositions, tokens)) { for (int[] range : innerRanges) {
markLeft[start] = true; if (range[0] - 1 > lastEnd + 1) {
markRight[end] = true; outerRanges.add(new int[]{lastEnd + 1, range[0] - 1});
placed = true; }
} lastEnd = range[1];
} }
} if (lastEnd + 1 < numPositions.size()) {
} outerRanges.add(new int[]{lastEnd + 1, numPositions.size() - 1});
}
//检测添加括号的合法性
private boolean canPlaceBracket(int start, int end, boolean[] markLeft, boolean[] markRight, boolean added = false;
List<Integer> numPositions, String[] tokens) { for (int[] range : outerRanges) {
if (isOuterMostBracket(start, end, markLeft.length)) return false; String outerExpr = extractTokens(result, range[0], range[1]);
if (isInvalidOverlap(start, end, markLeft, markRight)) return false; List<Integer> outerNumPos = getNumPositions(outerExpr);
return isValidBracketRange(tokens, numPositions, start, end); int outerPairs = decideParenthesesPairs(outerNumPos.size());
} if (outerPairs > 0) {
String newOuterExpr = addParentheses(outerExpr, outerPairs, outerNumPos);
//避免最外层括号 result = replaceTokens(result, range[0], range[1], newOuterExpr);
private boolean isOuterMostBracket(int start, int end, int numCount) { added = true;
return start == 0 && end == numCount - 1; }
} }
//允许嵌套但禁止交叉 return added ? result : expression;
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; private String addNestedInside(String expression) {
} String result = expression;
return false; List<int[]> innerRanges = getInnerBracketRanges(expression);
} for (int[] range : innerRanges) {
String innerExpr = extractTokens(result, range[0], range[1]);
//检测括号是否有意义（优先级） List<Integer> innerNumPos = getNumPositions(innerExpr);
private boolean isValidBracketRange(String[] tokens, List<Integer> numPositions, int start, int end) { int innerPairs = decideParenthesesPairs(innerNumPos.size());
int opStart = numPositions.get(start) + 1; String newInnerExpr = addParentheses(innerExpr, innerPairs, innerNumPos);
int opEnd = numPositions.get(end) - 1; result = replaceTokens(result, range[0], range[1], newInnerExpr);
String firstOp = null; }
boolean hasHigherOuterOp = false; return result;
}
for (int i = opStart; i <= opEnd; i += 2) {
if (!isNumber(tokens[i])) { // 添加括号核心逻辑
if (firstOp == null) firstOp = tokens[i]; private String addParentheses(String expression, int pairs, List<Integer> numPositions) {
else if (isDifferentPriority(firstOp, tokens[i])) { String[] tokens = expression.split(" "); // 按空格拆分
hasHigherOuterOp = true; int numCount = numPositions.size();
break; boolean[] markLeft = new boolean[numCount]; // 左括号标记
} boolean[] markRight = new boolean[numCount]; // 右括号标记
}
} generateBracketPositions(numCount, numPositions, pairs, tokens, markLeft, markRight); // 生成括号位置
return hasHigherOuterOp || firstOp == null; String result = insertBrackets(tokens, markLeft, markRight); // 插入括号
} return validateParentheses(result) ? result : expression; // 验证括号匹配，非法返回原表达式
}
//比较运算符优先级
private boolean isDifferentPriority(String op1, String op2) { // 生成括号位置
int p1 = (op1.equals("+") || op1.equals("-")) ? 1 : 2; private void generateBracketPositions(int numCount, List<Integer> numPositions, int pairs, String[] tokens,
int p2 = (op2.equals("+") || op2.equals("-")) ? 1 : 2; boolean[] markLeft, boolean[] markRight) {
return p1 != p2; int attempts = 0;
} for (int p = 0; p < pairs && attempts < 50; p++, attempts++) {
boolean placed = false;
//插入操作 for (int tries = 0; tries < 50 && !placed; tries++) {
private String insertBrackets(String[] tokens, boolean[] markLeft, boolean[] markRight) { int start = RANDOM.nextInt(numCount - 1); // 随机起始数字索引
StringBuilder sb = new StringBuilder(); int end = start + 1 + RANDOM.nextInt(numCount - start - 1); // 随机结束数字索引
int numIndex = 0; if (end >= numCount) {
for (String token : tokens) { end = numCount - 1;
if (isNumber(token)) { }
if (markLeft[numIndex]) sb.append("( ");
sb.append(token); // 40%概率尝试嵌套在已有括号内部
if (markRight[numIndex]) sb.append(" )"); if (RANDOM.nextDouble() < 0.4) {
numIndex++; for (int i = 0; i < numCount; i++) {
} else { if (markLeft[i]) {
sb.append(" ").append(token).append(" "); start = i;
} end = i + RANDOM.nextInt(numCount - i);
} break;
return sb.toString(); }
} }
}
//检查括号是否缺失
private boolean validateParentheses(String expr) { // 检查是否合法
int balance = 0; if (canPlaceBracket(start, end, markLeft, markRight, numPositions, tokens)) {
for (char c : expr.toCharArray()) { markLeft[start] = true;
if (c == '(') balance++; markRight[end] = true;
if (c == ')') balance--; placed = true;
if (balance < 0) return false; }
} }
return balance == 0; }
} }
private boolean isNumber(String token) { // 检查括号是否可以放置
try { Integer.parseInt(token); return true; } private boolean canPlaceBracket(int start, int end, boolean[] markLeft, boolean[] markRight,
catch (NumberFormatException e) { return false; } List<Integer> 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<Integer> 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<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();
}
}

Write Preview
Loading…
Cancel
Save