from typing import List, Optional, Dict, Any import random class Question: """ 问题类，用于生成不同类型的24点题目 """ # 缓存数据 _cache = { 'A': [], # 推理未知数题目 'B': [], # 恰好有两个解法的题目 'C': [], # 有三个或以上解法的题目 'D': [], # 包含flag=1的题目 'E': [] # 包含flag=2的题目 } _is_cache_loaded = False def __init__(self, q_type: str): self.type = q_type self.question = "" self.numbers: List[Optional[int]] = [] self.answers: List[Any] = [] # 确保缓存已加载 if not Question._is_cache_loaded: Question._load_cache() @classmethod def _load_cache(cls): """ 从core.load模块加载缓存数据并按题型和特性分类 """ try: # 初始化缓存结构 cls._cache = { 'A': [], # 推理未知数题目 'B': [], # 恰好有两个解法的题目 'C': [], # 有三个或以上解法的题目 'D': [], # 包含flag=1的题目 'E': [] # 包含flag=2的题目 } # 从core.load模块获取数据 from core.load import all_data data = all_data # 分类处理数据 for item in data: # 从GameDataDTO构建numbers数组 numbers = [item.num1, item.num2, item.num3, item.num4] solutions = item.solutions # 转换解法格式 formatted_solutions = [] for sol in solutions: formatted_solutions.append({ 'expression': sol.expression, 'flag': sol.flag }) # 构建标准格式的题目数据 formatted_item = { 'id': item.id, 'no': item.no, 'numbers': numbers, 'solutions': formatted_solutions } if not solutions: continue # 计算解法数量和最高flag值 solution_count = len(solutions) max_flag = max([sol.flag for sol in solutions], default=0) # 分类存储 # 类型A：推理未知数题目 - 只有4个数字中有两个相同的题目才可以用于类型A # 检查numbers中是否有两个相同的数字 num_count = {} for num in numbers: num_count[num] = num_count.get(num, 0) + 1 has_duplicate = any(count == 2 for count in num_count.values()) if solution_count > 0 and has_duplicate: cls._cache['A'].append(formatted_item) # 类型B：恰好有两个解法的题目 if solution_count == 2: cls._cache['B'].append(formatted_item) # 类型C：有三个或以上解法的题目 if solution_count >= 3: cls._cache['C'].append(formatted_item) # 类型D：包含flag=1的题目 if max_flag == 1: cls._cache['D'].append(formatted_item) # 类型E：包含flag=2的题目 if max_flag == 2: cls._cache['E'].append(formatted_item) cls._is_cache_loaded = True print(f"缓存加载完成，各类型题目数量：A:{len(cls._cache['A'])}, B:{len(cls._cache['B'])}, C:{len(cls._cache['C'])}, D:{len(cls._cache['D'])}, E:{len(cls._cache['E'])}") except Exception as e: print(f"加载缓存数据失败: {e}") cls._is_cache_loaded = False def generate(self) -> Dict[str, Any]: """ 根据题型生成题目 """ valid_types = ["A", "B", "C", "D", "E"] # 如果类型无效，随机选择一个有效类型 if self.type not in valid_types: self.type = random.choice(valid_types) return self.generate() # 调用对应类型的生成方法 generator_method = getattr(self, f"_generate_type_{self.type.lower()}") data = generator_method() data['type'] = self.type return data @classmethod def _ensure_cache_loaded(cls, cache_type: str) -> None: """ 确保缓存已加载，并验证指定类型的缓存是否有可用数据 """ if not cls._is_cache_loaded: cls._load_cache() if not cls._cache[cache_type]: raise ValueError(f"缓存中没有可用的{cache_type}类型题目数据") @classmethod def _get_random_item(cls, cache_type: str) -> Dict[str, Any]: """ 从指定类型的缓存中随机获取一个题目 """ cls._ensure_cache_loaded(cache_type) return random.choice(cls._cache[cache_type]) @classmethod def _format_solutions(cls, solutions: List[Dict], flag_value: Optional[int] = None) -> List[Dict]: """ 统一格式化解法数据 如果指定了flag_value，则只保留该flag值的解法 """ answers = [] for solution in solutions: # 如果指定了flag值且当前解法的flag不匹配，则跳过 if flag_value is not None and solution.get('flag', 0) != flag_value: continue answers.append({ "expression": solution.get('expression', ''), "flag": flag_value if flag_value is not None else solution.get('flag', 0) }) return answers @classmethod def _create_question_result(cls, question_text: str, numbers: List, answers: List) -> Dict[str, Any]: """ 创建标准格式的问题结果对象 """ return { "question": question_text, "numbers": numbers, "answers": answers } @classmethod def _generate_type_a(cls) -> Dict[str, Any]: """ 推理未知数：给出四个数字（1-13）算24，其中一个是x，并且x等于另外三个数（这三个数不能相同）中的一个。 要求找出x的可能值，并写出相应的算式 """ # 获取随机题目 item = cls._get_random_item('A') original_numbers = item.get('numbers', []) solutions = item.get('solutions', []) if len(original_numbers) != 4 or not solutions: raise ValueError("缓存数据格式不正确") # 找出重复的数字和不重复的数字 num_count = {} for num in original_numbers: num_count[num] = num_count.get(num, 0) + 1 # 找出重复的数字（出现次数为2的数字） duplicate_num = None for num, count in num_count.items(): if count == 2: duplicate_num = num break if duplicate_num is None: raise ValueError("A类型题目数据中没有重复的数字") # 收集三个不同的数字（包括重复的那个数字） distinct_nums = [] for num in num_count.keys(): if num not in distinct_nums: distinct_nums.append(num) if len(distinct_nums) >= 3: break # 随机选择一个位置放置未知数 unknown_pos = random.randint(0, 3) numbers = distinct_nums.copy() numbers.insert(unknown_pos, None) # None 表示未知数 x # 构造答案 answers = [] for possible_x in distinct_nums: # 构建排序后的测试数字组合 test_numbers = sorted([n if n is not None else possible_x for n in numbers]) test_no = f"{test_numbers[0]}_{test_numbers[1]}_{test_numbers[2]}_{test_numbers[3]}" # 收集当前x值的所有解法 for item in cls._cache['A']: if item.get('no', "") == test_no: solution = item.get('solutions', []) # 使用正确的 join 方法 solution_str = ", ".join([sol['expression'] for sol in solution]) answers.append(f"当X={possible_x}时，解法为：{solution_str}") # 构造问题文本 question_text = "推理未知数：给出四个数字算24点，其中一个是未知数x，且x等于另外三个数中的一个。请找出x的可能值，并写出对应算式。" if len(answers)>1: question_text += f"（共有{len(answers)}个答案，请写全）" return cls._create_question_result(question_text, numbers, answers) @classmethod def _generate_type_b(cls) -> Dict[str, Any]: """ 一题多解1：生成恰好有两个解法的题目 """ # 获取随机题目 item = cls._get_random_item('B') numbers = item.get('numbers', []) solutions = item.get('solutions', []) question_text = "一题多解：请找出这组数字的所有24点解法。" # 格式化解法 answers = cls._format_solutions(solutions) return cls._create_question_result(question_text, numbers, answers) @classmethod def _generate_type_c(cls) -> Dict[str, Any]: """ 一题多解2：生成有三个或以上解法的题目 """ # 获取随机题目 item = cls._get_random_item('C') numbers = item.get('numbers', []) solutions = item.get('solutions', []) question_text = "一题多解：请找出这组数字的所有24点解法!" # 格式化解法 answers = cls._format_solutions(solutions) return cls._create_question_result(question_text, numbers, answers) @classmethod def _generate_type_d(cls) -> Dict[str, Any]: """ 一星题目：生成包含flag=1的题目 """ # 获取随机题目 item = cls._get_random_item('D') numbers = item.get('numbers', []) solutions = item.get('solutions', []) question_text = "【一星】题目：请找出这组数字的24点解法。" # 格式化解法，只保留flag=1的解法 answers = cls._format_solutions(solutions, flag_value=1) return cls._create_question_result(question_text, numbers, answers) @classmethod def _generate_type_e(cls) -> Dict[str, Any]: """ 二星题目：生成包含flag=2的题目 """ # 获取随机题目 item = cls._get_random_item('E') numbers = item.get('numbers', []) solutions = item.get('solutions', []) question_text = "【二星】题目：请找出这组数字的24点解法。" # 格式化解法，只保留flag=2的解法 answers = cls._format_solutions(solutions, flag_value=2) return cls._create_question_result(question_text, numbers, answers)