生成初中难度的数学题目，包含平方(²)和开根号(√)运算符
+ 确保每个题目至少有一个平方或开根号运算符，并且这些运算符处理的操作数
+ 需要通过四则运算符与其他操作数连接
+ */
+public class JuniorQuestionGenerator implements QuestionGenerator {
+ private static final String[] BINARY_OPERATORS = {"+", "-", "*", "/"};
+ private static final String[] UNARY_OPERATORS = {"²", "√"};
+ private static final int MIN_OPERAND_COUNT = 3;
+ private static final int MAX_OPERAND_COUNT = 5;
+ private static final int MIN_OPERAND_VALUE = 1;
+ private static final int MAX_OPERAND_VALUE = 100;
+ private static final double UNARY_OPERATOR_PROBABILITY = 0.6;
+
+ private final Random random;
+
+ /**
+ 构造函数
+ */
+ public JuniorQuestionGenerator() {
+ this.random = new Random();
+ }
+
+ /**
+ 生成指定数量的初中题目
+ @param count 要生成的题目数量
+ @return 题目列表，包含指定数量的初中难度题目
+ */
+ @Override
+ public List 确保题目中至少有一个平方或开根号的运算符，并且这些运算符处理的操作数
+ 需要通过四则运算符与其他操作数连接
+ @return 单个题目对象
+ */
+ @Override
+ public Question generateQuestion() {
+ String expression;
+ boolean hasAdvancedOperator;
+ boolean hasBinaryConnection;
+
+ // 循环生成直到满足条件
+ do {
+ expression = generateValidExpression();
+ hasAdvancedOperator = containsAdvancedOperator(expression);
+ hasBinaryConnection = hasBinaryOperatorConnection(expression);
+ } while (!hasAdvancedOperator || !hasBinaryConnection);
+
+ return new Question(0, expression);
+ }
+
+ /**
+ * 获取题目生成器的类型
+ *
+ * @return 类型字符串"初中"
+ */
+ @Override
+ public String getType() {
+ return "初中";
+ }
+
+ /**
+ * 生成有效的表达式
+ *
+ * 生成包含操作数和运算符的表达式，确保有足够的操作数来支持四则运算连接
+ *
+ * @return 有效的表达式字符串
+ */
+ private String generateValidExpression() {
+ int operandCount = random.nextInt(MAX_OPERAND_COUNT - MIN_OPERAND_COUNT + 1) + MIN_OPERAND_COUNT;
+ StringBuilder expression = new StringBuilder();
+
+ // 添加第一个操作数，可能应用一元运算符
+ expression.append(generateOperandWithPossibleUnaryOperator());
+
+ // 添加后续操作数和运算符
+ for (int i = 1; i < operandCount; i++) {
+ expression.append(" ").append(generateBinaryOperator()).append(" ");
+ expression.append(generateOperandWithPossibleUnaryOperator());
+ }
+
+ return expression.toString();
+ }
+
+ /**
+ * 生成可能带有一元运算符的操作数
+ *
+ * @return 可能应用了一元运算符的操作数字符串
+ */
+ private String generateOperandWithPossibleUnaryOperator() {
+ String operand = generateOperand();
+
+ // 根据概率决定是否应用一元运算符
+ if (random.nextDouble() < UNARY_OPERATOR_PROBABILITY) {
+ String operator = UNARY_OPERATORS[random.nextInt(UNARY_OPERATORS.length)];
+ return applyUnaryOperator(operand, operator);
+ }
+
+ return operand;
+ }
+
+ /**
+ * 应用一元运算符到操作数
+ *
+ * @param operand 操作数
+ * @param operator 一元运算符
+ * @return 应用运算符后的表达式
+ */
+ private String applyUnaryOperator(String operand, String operator) {
+ switch (operator) {
+ case "²":
+ return "(" + operand + ")²";
+ case "√":
+ return "√(" + operand + ")";
+ default:
+ return operand;
+ }
+ }
+
+ /**
+ * 生成操作数（1-100）
+ *
+ * @return 操作数字符串
+ */
+ private String generateOperand() {
+ return String.valueOf(random.nextInt(MAX_OPERAND_VALUE) + MIN_OPERAND_VALUE);
+ }
+
+ /**
+ * 生成二元运算符
+ *
+ * @return 二元运算符字符串
+ */
+ private String generateBinaryOperator() {
+ return BINARY_OPERATORS[random.nextInt(BINARY_OPERATORS.length)];
+ }
+
+ /**
+ * 检查表达式是否包含高级运算符（平方或开根号）
+ *
+ * @param expression 数学表达式
+ * @return 如果包含高级运算符返回true，否则返回false
+ */
+ private boolean containsAdvancedOperator(String expression) {
+ return expression.contains("²") || expression.contains("√");
+ }
+
+ /**
+ * 检查高级运算符处理的操作数是否有四则运算符连接其他操作数
+ *
+ * 确保平方或根号处理的操作数不是孤立存在的，而是通过四则运算与其他操作数连接
+ *
+ * @param expression 数学表达式
+ * @return 如果满足连接条件返回true，否则返回false
+ */
+ private boolean hasBinaryOperatorConnection(String expression) {
+ // 如果表达式包含高级运算符，检查是否有足够的二元运算符连接
+ if (containsAdvancedOperator(expression)) {
+ int binaryOperatorCount = countBinaryOperators(expression);
+ // 至少需要1个二元运算符来连接操作数
+ return binaryOperatorCount >= 1;
+ }
+ return false;
+ }
+
+ /**
+ * 计算表达式中二元运算符的数量
+ *
+ * @param expression 数学表达式
+ * @return 二元运算符的数量
+ */
+ private int countBinaryOperators(String expression) {
+ int count = 0;
+ for (String operator : BINARY_OPERATORS) {
+ // 简单的计数方法，实际可能需要更复杂的解析
+ int index = expression.indexOf(operator);
+ while (index >= 0) {
+ count++;
+ index = expression.indexOf(operator, index + 1);
+ }
+ }
+ return count;
+ }
+
+ /**
+ * 生成一个确保满足条件的表达式（备用方法）
+ *
+ * 这个方法确保生成的表达式一定包含高级运算符并且有二元运算符连接
+ *
+ * @return 满足条件的表达式
+ */
+ private String generateGuaranteedValidExpression() {
+ StringBuilder expression = new StringBuilder();
+
+ // 至少生成3个操作数以确保有连接
+ int operandCount = random.nextInt(MAX_OPERAND_COUNT - MIN_OPERAND_COUNT + 1) + MIN_OPERAND_COUNT;
+
+ // 第一个操作数：普通操作数
+ expression.append(generateOperand());
+ expression.append(" ").append(generateBinaryOperator()).append(" ");
+
+ // 第二个操作数：应用高级运算符
+ String advancedOperand = generateOperand();
+ String unaryOperator = UNARY_OPERATORS[random.nextInt(UNARY_OPERATORS.length)];
+ expression.append(applyUnaryOperator(advancedOperand, unaryOperator));
+
+ // 如果有更多操作数，继续添加
+ for (int i = 2; i < operandCount; i++) {
+ expression.append(" ").append(generateBinaryOperator()).append(" ");
+ // 随机决定是否应用一元运算符
+ if (random.nextBoolean()) {
+ expression.append(generateOperandWithPossibleUnaryOperator());
+ } else {
+ expression.append(generateOperand());
+ }
+ }
+
+ return expression.toString();
+ }
+}
+=======
+package main.java.generator;
+
+public class JuniorQuestionGenerator {
+}
+>>>>>>> 93d8b771666e4fb2ee7477c19dcf6f4fb1eec045
diff --git a/src/main/java/generator/PrimaryQuestionGenerator.java b/src/main/java/generator/PrimaryQuestionGenerator.java
new file mode 100644
index 0000000..3986c7b
--- /dev/null
+++ b/src/main/java/generator/PrimaryQuestionGenerator.java
@@ -0,0 +1,208 @@
+<<<<<<< HEAD
+package generator;
+
+import entity.Question;
+import factory.QuestionGenerator;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+/**
+ 小学题目生成器
+ 生成小学难度的数学题目，只包含加减乘除和括号
+ 确保每个题目至少有两个操作数，操作数范围1-100
+ */
+public class PrimaryQuestionGenerator implements QuestionGenerator {
+ private static final String[] OPERATORS = {"+", "-", "*", "/"};
+ private static final int MIN_OPERAND_COUNT = 2;
+ private static final int MAX_OPERAND_COUNT = 5;
+ private static final int MIN_OPERAND_VALUE = 1;
+ private static final int MAX_OPERAND_VALUE = 100;
+ private static final double PARENTHESIS_PROBABILITY = 0.3;
+
+ private final Random random;
+
+ /**
+ 构造函数
+ */
+ public PrimaryQuestionGenerator() {
+ this.random = new Random();
+ }
+
+ /**
+ 生成指定数量的小学题目
+ @param count 要生成的题目数量
+ @return 题目列表，包含指定数量的小学难度题目
+ */
+ @Override
+ public List 题目包含2-5个操作数，操作数范围1-100
+ 只包含加减乘除运算符，可能包含括号
+ @return 单个题目对象
+ */
+ @Override
+ public Question generateQuestion() {
+ // 生成基础表达式（不带括号）
+ String baseExpression = generateBaseExpression();
+
+ // 随机决定是否添加括号
+ String finalExpression = maybeAddParentheses(baseExpression);
+
+ return new Question(0, finalExpression);
+ }
+
+ /**
+ 获取题目生成器的类型
+ @return 类型字符串"小学"
+ */
+ @Override
+ public String getType() {
+ return "小学";
+ }
+
+ /**
+ 生成基础表达式（不带括号）
+ @return 基础表达式字符串
+ */
+ private String generateBaseExpression() {
+ int operandCount = random.nextInt(MAX_OPERAND_COUNT - MIN_OPERAND_COUNT + 1) + MIN_OPERAND_COUNT;
+ StringBuilder expression = new StringBuilder();
+
+ // 添加第一个操作数
+ expression.append(generateOperand());
+
+ // 添加后续操作数和运算符
+ for (int i = 1; i < operandCount; i++) {
+ expression.append(" ").append(generateOperator()).append(" ");
+ expression.append(generateOperand());
+ }
+
+ return expression.toString();
+ }
+
+ /**
+ 随机决定是否为表达式添加括号
+ @param expression 原始表达式
+ @return 可能添加括号后的表达式
+ */
+ private String maybeAddParentheses(String expression) {
+ // 只有当操作数大于2时才考虑添加括号
+ if (countOperands(expression) > 2 && random.nextDouble() < PARENTHESIS_PROBABILITY) {
+ return addParentheses(expression);
+ }
+ return expression;
+ }
+
+ /**
+ 为表达式添加括号
+ 在表达式中随机选择一个子表达式添加括号
+ @param expression 原始表达式
+ @return 添加括号后的表达式
+ */
+ private String addParentheses(String expression) {
+ String[] parts = expression.split(" ");
+
+ // 如果表达式太短，直接为整个表达式添加括号
+ if (parts.length <= 3) {
+ return "(" + expression + ")";
+ }
+
+ // 随机选择括号的起始位置（操作数的位置）
+ int startPos = random.nextInt(parts.length / 2) * 2; // 确保在操作数位置
+
+ // 随机选择括号的长度（包含的操作数数量，至少2个）
+ int maxLength = (parts.length - startPos) / 2 + 1;
+ int length = random.nextInt(maxLength - 1) + 2; // 至少2个操作数
+
+ // 计算结束位置
+ int endPos = startPos + (length * 2 - 1);
+ if (endPos >= parts.length) {
+ endPos = parts.length - 1;
+ }
+
+ // 构建带括号的表达式
+ StringBuilder result = new StringBuilder();
+ for (int i = 0; i < parts.length; i++) {
+ if (i == startPos) {
+ result.append("(");
+ }
+
+ result.append(parts[i]);
+
+ if (i == endPos) {
+ result.append(")");
+ }
+
+ if (i < parts.length - 1) {
+ result.append(" ");
+ }
+ }
+
+ return result.toString();
+ }
+
+ /**
+ 计算表达式中的操作数数量
+ @param expression 数学表达式
+ @return 操作数的数量
+ */
+ private int countOperands(String expression) {
+ // 简单估算：操作数数量 ≈ (分割后的数组长度 + 1) / 2
+ String[] parts = expression.split(" ");
+ return (parts.length + 1) / 2;
+ }
+
+ /**
+ 生成操作数（1-100）
+ @return 操作数字符串
+ */
+ private String generateOperand() {
+ return String.valueOf(random.nextInt(MAX_OPERAND_VALUE) + MIN_OPERAND_VALUE);
+ }
+
+ /**
+ 生成运算符
+ @return 运算符字符串
+ */
+ private String generateOperator() {
+ return OPERATORS[random.nextInt(OPERATORS.length)];
+ }
+
+ /**
+ 生成一个确保有两个操作数的表达式（备用方法）
+ 这个方法确保生成的表达式至少有两个操作数
+ @return 至少有两个操作数的表达式
+ */
+ private String generateGuaranteedTwoOperandExpression() {
+ StringBuilder expression = new StringBuilder();
+
+ // 确保至少有两个操作数
+ int operandCount = random.nextInt(MAX_OPERAND_COUNT - MIN_OPERAND_COUNT + 1) + MIN_OPERAND_COUNT;
+
+ // 添加第一个操作数
+ expression.append(generateOperand());
+
+ // 添加后续操作数和运算符
+ for (int i = 1; i < operandCount; i++) {
+ expression.append(" ").append(generateOperator()).append(" ");
+ expression.append(generateOperand());
+ }
+
+ return expression.toString();
+ }
+}
+=======
+package main.java.generator;
+
+public class PrimaryQuestionGenerator {
+}
+>>>>>>> 93d8b771666e4fb2ee7477c19dcf6f4fb1eec045
diff --git a/src/main/java/generator/SeniorQuestionGenerator.java b/src/main/java/generator/SeniorQuestionGenerator.java
new file mode 100644
index 0000000..9963ecb
--- /dev/null
+++ b/src/main/java/generator/SeniorQuestionGenerator.java
@@ -0,0 +1,234 @@
+<<<<<<< HEAD
+package generator;
+
+import entity.Question;
+import factory.QuestionGenerator;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+/**
+ 高中题目生成器（包含三角函数）
+ 生成高中难度的数学题目，确保每个题目至少包含一个三角函数
+ 操作数范围：1-100
+ 操作数数量：1-5个
+ */
+public class SeniorQuestionGenerator implements QuestionGenerator {
+ private static final String[] BINARY_OPERATORS = {"+", "-", "*", "/"};
+ private static final String[] TRIGONOMETRIC_FUNCTIONS = {"sin", "cos", "tan"};
+ private final Random random = new Random();
+
+ /**
+ 生成指定数量的高中题目
+ @param count 题目数量
+ @return 题目列表
+ */
+ @Override
+ public List