一、考试题型与分值分布

人工智能训练师（三级）机考题型总览：

┌──────────────────────────────────────────────────────────────────┐
│                     机考试卷结构（120分钟）                         │
├────────────┬──────────┬───────────┬──────────┬───────────────────┤
│   题型      │  题量     │  单题分值  │  预估耗时 │  说明              │
├────────────┼──────────┼───────────┼──────────┼───────────────────┤
│ 单选题      │  ~60题   │  1分/题    │  ~40min │ 四选一，基础考察     │
│ 多选题      │  ~20题   │  2分/题    │  ~25min │ 少选/错选不得分     │
│ 判断题      │  ~20题   │  1分/题    │  ~15min │ 对错二选一          │
│ 简答题/案例  │  ~5题    │  6分/题    │  ~30min │ 需要结构化作答       │
├────────────┼──────────┼───────────┼──────────┼───────────────────┤
│ 合计        │  ~105题  │           │  ~110min│ 预留10min检查       │
└────────────┴──────────┴───────────┴──────────┴───────────────────┘

120分钟黄金配比：
  40min 单选题 → 25min 多选题 → 15min 判断题 → 30min 简答题 → 10min 检查

二、选择题答题策略

2.1 单选题「三步排除法」

单选题解题流程：

  拿到一道单选题
        │
        ▼
  ┌─────────────────┐
  │ Step 1: 审题圈画  │ → 划出关键词（不是/错误的是/正确的是）
  │ 5秒              │ → 明确题目问什么
  └────────┬────────┘
           │
           ▼
  ┌─────────────────┐
  │ Step 2: 排除错误项│ → 肯定错的直接划掉
  │ 10秒             │ → 优先排除: 绝对化词汇(总是/从不/完全)
  │                  │ → 其次排除: 概念明显混淆的选项
  └────────┬────────┘
           │
           ▼
  ┌──────────────────┐
  │ Step 3: 对比选择  │ → 剩余2项中，选最符合概念的
  │ 10秒              │ → 如不确定，标记跳过，回头再想
  └──────────────────┘

  平均每题 ≤30秒

排除口诀：
  绝对表述先排除（总是/绝不/完全/肯定）
  概念混淆要警惕（张冠李戴的术语）
  数字错误容易出（记错的阈值和参数）
  生僻选项多为坑（完全没见过的可能是干扰项）

2.2 多选题「全维度扫描法」

多选题解题策略：

  ┌─────────────────────────────────────────────────┐
  │              多选题全维度扫描                       │
  ├─────────────────────────────────────────────────┤
  │                                                  │
  │  ① 当作判断题集来做 — 每个选项独立判断对错          │
  │     A[] B[] C[] D[] E[]                          │
  │                                                  │
  │  ② 宁可少选不错选（少选得部分分时）                  │
  │     ⚠ 注意：多数考试少选错选均不得分！              │
  │                                                  │
  │  ③ 警惕「以上都对」「以上都错」                      │
  │     → 逐一验证每个选项后再判断                      │
  │                                                  │
  │  ④ 排除法逆向应用                                  │
  │     → 确定的错项标记排除，其余可能都对               │
  │                                                  │
  │  ⑤ 知识覆盖面检查                                  │
  │     → 正确选项通常覆盖不同维度的知识点               │
  │     → 互相矛盾的选项不会同时正确                    │
  │                                                  │
  └─────────────────────────────────────────────────┘

  平均每题 60-90秒

三、判断题关键词法

判断题高效应答策略：

  ┌─────────────────────────────────────────────────────┐
  │               判断题「关键词速判法」                    │
  ├─────────────────────────────────────────────────────┤
  │                                                      │
  │  🟢 看到这些词 → 很可能是「×」（错误）:                 │
  │     ● 绝对化：总是、从不、完全、绝对、一定、必须           │
  │     ● 极端化：百分之百、永远、全部、无一例外               │
  │     ● 过度简化：只需要、就是、即、等于                    │
  │                                                      │
  │  🟡 看到这些词 → 仔细审题，可能对可能错:                  │
  │     ● 相对化：通常、一般、多数、往往、可能                  │
  │     ● 限定化：在某些情况下、在一定条件下                    │
  │                                                      │
  │  🔵 核心判断原则：                                      │
  │     ● 概念定义题 → 查描述是否完整准确                    │
  │     ● 数字/阈值题 → 回忆具体数值，别被偷换                │
  │     ● 逻辑关系题 → 因果关系/包含关系是否正确               │
  │                                                      │
  └─────────────────────────────────────────────────────┘

  平均每题 30-45秒

典型陷阱示例：
  ✗ "监督学习完全不需要标签数据" → 明显错误（需要标签）
  ✗ "过拟合总是可以通过增加数据量解决" → 绝对化，不一定
  ✓ "PSI是评估模型稳定性的常用指标之一" → 相对化，正确

四、简答题结构法

简答题「金字塔应答结构」：

                     ┌─────┐
                     │结论/ │  ← ① 开门见山，先给答案（10%篇幅）
                     │定义  │
                     └──┬──┘
                ┌───────┼───────┐
                ▼       ▼       ▼
           ┌──────┐ ┌──────┐ ┌──────┐
           │要点1 │ │要点2 │ │要点3 │  ← ② 分点阐述核心内容（60%篇幅）
           │+举例 │ │+举例 │ │+举例 │
           └──┬───┘ └──┬───┘ └──┬───┘
              └────────┼────────┘
                       ▼
                 ┌──────────┐
                 │ 总结/应用  │  ← ③ 一句话总结或联系实际（30%篇幅）
                 │ 场景      │
                 └──────────┘

简答题评分要点：
  ● 关键概念准确 → 得基础分
  ● 分点清晰 → 阅卷人容易找到得分点
  ● 有案例或举例 → 展示理解深度
  ● 逻辑完整 → 体现综合能力

简答题常见题型模板：

  【概念解释型】
  "简述XXX是什么？"
  → 定义（1句话）+ 核心特征（2-3点）+ 举例说明（1个）

  【对比分析型】
  "比较A和B的区别/联系？"
  → 分别定义A和B + 对比维度(3点)+ 总结差异本质

  【方案设计型】
  "如何解决XXX问题？"
  → 问题分析(1句)+ 解决思路(2-3步)+ 注意事项(1-2点)

五、难题跳过策略

考试中遇到难题怎么办？

  ┌───────────────────────────────────────────────────┐
  │             「三级跳」难题处理策略                    │
  ├───────────────────────────────────────────────────┤
  │                                                    │
  │  Level 1：30秒原则                                 │
  │  ├─ 读题后30秒内没有思路 → 立即标记，跳过            │
  │  ├─ 不要纠结！不要反复读！                          │
  │  └─ 系统自带的「标记」功能好好利用                    │
  │                                                    │
  │  Level 2：首轮快扫策略                               │
  │  ├─ 第一遍：只做「秒答」的题（看完就会的）            │
  │  ├─ 标记：「需要思考的」+「完全不会的」               │
  │  └─ 目标：45分钟内完成全部简单题                     │
  │                                                    │
  │  Level 3：二轮攻坚策略                               │
  │  ├─ 第二遍：处理「需要思考的」题目                    │
  │  ├─ 使用排除法缩小范围，实在不行用选项规律猜          │
  │  └─ 目标：再争取得分，不空题                         │
  │                                                    │
  │  Level 4：最终盲猜策略                               │
  │  ├─ 第三遍：处理「完全不会的」题目                    │
  │  ├─ 单选题：选C/B（排除明显错后蒙）                   │
  │  ├─ 判断题：倾向于判断为错（错题比例通常偏高）          │
  │  └─ 多选题：选最有把握的2-3项                        │
  │                                                    │
  └───────────────────────────────────────────────────┘

  ⚠ 铁律：绝不空题！机考不扣分，不答=零分，猜了还有概率对！

六、检查策略

检查的「优先级矩阵」：

  高优先级（必检查）
  ├─ 标记过的题目 → 重新审视，可能有坑
  ├─ 计算类题目 → 重新算一遍
  └─ 多选题 → 确认是否少选/多选

  中优先级（重点检查）
  ├─ 判断题含「绝对化」词汇的 → 复核
  └─ 简答题 → 检查是否遗漏要点

  低优先级（时间够才检查）
  ├─ 秒答的单选题 → 可能因粗心选错
  └─ 题号顺序 → 确认没漏题

检查时三不问：
  ✗ 不轻易改答案（除非确信第一次错了）
  ✗ 不反复读同一道题（浪费时间）
  ✗ 不纠结"两个都对"的选项（选最符合作答的）

七、Python 工具类：TimeAllocator

"""
TimeAllocator — 机考答题时间智能分配器
用法：根据题型、题量自动计算时间分配，支持动态跟踪和重分配
"""
from dataclasses import dataclass, field
from typing import List, Dict, Tuple
from enum import Enum


class QuestionType(Enum):
    SINGLE_CHOICE = "单选题"
    MULTI_CHOICE = "多选题"
    TRUE_FALSE = "判断题"
    SHORT_ANSWER = "简答题"


@dataclass
class QuestionSection:
    """题型部分"""
    qtype: QuestionType
    total_count: int
    points_each: float
    suggested_time: int  # 分钟
    completed: int = 0
    time_spent: int = 0  # 实际耗时（分钟）
    marked: List[int] = field(default_factory=list)  # 标记的题号


class TimeAllocator:
    """考试时间管理器"""
    
    DEFAULT_ALLOCATION = {
        QuestionType.SINGLE_CHOICE: {"count": 60, "points": 1, "time": 40, "per_q_sec": 40},
        QuestionType.MULTI_CHOICE:  {"count": 20, "points": 2, "time": 25, "per_q_sec": 75},
        QuestionType.TRUE_FALSE:    {"count": 20, "points": 1, "time": 15, "per_q_sec": 45},
        QuestionType.SHORT_ANSWER:  {"count": 5,  "points": 6, "time": 30, "per_q_sec": 360},
    }
    
    def __init__(self, total_time: int = 120, custom_config: Dict = None):
        """
        total_time: 总考试时间（分钟）
        custom_config: 自定义题型配置
        """
        self.total_time = total_time
        self.elapsed = 0
        self.sections: Dict[QuestionType, QuestionSection] = {}
        
        config = custom_config or self.DEFAULT_ALLOCATION
        for qtype, cfg in config.items():
            self.sections[qtype] = QuestionSection(
                qtype=qtype,
                total_count=cfg["count"],
                points_each=cfg["points"],
                suggested_time=cfg["time"],
            )
        
        self.reserve_check_time = 10  # 预留检查时间
    
    def get_total_suggested_time(self) -> int:
        """获取建议总时间"""
        return sum(s.suggested_time for s in self.sections.values()) + self.reserve_check_time
    
    def get_status(self) -> List[Dict]:
        """获取各题型答题状态"""
        result = []
        for qtype, section in self.sections.items():
            progress = section.completed / section.total_count * 100 if section.total_count > 0 else 0
            time_used_pct = section.time_spent / section.suggested_time * 100 if section.suggested_time > 0 else 0
            remaining = section.total_count - section.completed
            
            # 判断是否超时
            if time_used_pct > 100:
                status = "🔴 超时"
            elif time_used_pct > 85:
                status = "🟡 预警"
            else:
                status = "🟢 正常"
            
            result.append({
                "题型": qtype.value,
                "进度": f"{section.completed}/{section.total_count} ({progress:.0f}%)",
                "已用时": f"{section.time_spent}min",
                "建议用时": f"{section.suggested_time}min",
                "剩余": str(remaining),
                "标记": len(section.marked),
                "状态": status,
            })
        return result
    
    def record_progress(self, qtype: QuestionType, completed: int, time_spent: int, marked: List[int] = None):
        """记录答题进度"""
        if qtype in self.sections:
            section = self.sections[qtype]
            section.completed = min(completed, section.total_count)
            section.time_spent = time_spent
            if marked:
                section.marked = marked
    
    def get_time_reallocation(self) -> Dict:
        """根据当前进度重新分配剩余时间"""
        remaining_total = self.total_time - self.elapsed - self.reserve_check_time
        
        # 计算各题型剩余题量和加权时间
        unfinished = {}
        total_remaining_questions = 0
        for qtype, section in self.sections.items():
            remaining = section.total_count - section.completed
            if remaining > 0:
                # 加权：根据分值和题量
                weight = remaining * section.points_each
                unfinished[qtype] = {"remaining": remaining, "weight": weight}
                total_remaining_questions += weight
        
        if total_remaining_questions == 0:
            return {"message": "全部完成！转入检查阶段"}
        
        realloc = {}
        for qtype, info in unfinished.items():
            allocated = int(remaining_total * info["weight"] / total_remaining_questions)
            per_q = allocated / info["remaining"] if info["remaining"] > 0 else 0
            realloc[qtype.value] = {
                "剩余题量": info["remaining"],
                "建议分配时间": f"{allocated}min",
                "每题上限": f"{per_q:.0f}秒",
            }
        
        return realloc
    
    def should_skip(self, qtype: QuestionType, thinking_seconds: int) -> Tuple[bool, str]:
        """判断当前题目是否应该跳过"""
        config = self.DEFAULT_ALLOCATION.get(qtype, {})
        per_q_time = config.get("per_q_sec", 60)
        
        if thinking_seconds > per_q_time * 1.5:
            return True, f"已思考{thinking_seconds}秒，超过建议{per_q_time}秒的150%，建议标记跳过"
        elif thinking_seconds > per_q_time:
            return False, f"已思考{thinking_seconds}秒，接近建议时间上限，需加快"
        else:
            return False, "时间充裕，正常作答"
    
    def print_dashboard(self):
        """打印答题仪表盘"""
        bar = "─" * 70
        print(f"\n{bar}")
        print(f"  考试答题仪表盘 — 已过{self.elapsed}min / 总计{self.total_time}min")
        print(f"{bar}")
        print(f"  {'题型':<12} {'进度':<14} {'已用时':<10} {'建议用时':<10} {'标记':<6} {'状态'}")
        print(f"  {'-' * 66}")
        
        for status in self.get_status():
            print(f"  {status['题型']:<12} {status['进度']:<14} {status['已用时']:<10} "
                  f"{status['建议用时']:<10} {status['标记']:<6} {status['状态']}")
        
        print(f"{bar}")
        remaining = self.total_time - self.elapsed
        print(f"  剩余时间：{remaining}min  |  建议检查时间：{self.reserve_check_time}min")
        
        # 重新分配建议
        realloc = self.get_time_reallocation()
        if isinstance(realloc, dict) and "message" not in realloc:
            print(f"\n  📋 剩余时间重新分配建议：")
            for qtype_name, info in realloc.items():
                print(f"     {qtype_name}: {info['剩余题量']}题 → {info['建议分配时间']}，"
                      f"每题约{info['每题上限']}")
        
        print(f"{bar}\n")
    
    def simulate_strategy(self):
        """模拟完整答题策略"""
        strategies = {
            "首轮快扫 (0-45min)": "只做秒答题，标记思考和难题",
            "二轮攻坚 (45-75min)": "处理标记的思考题，用排除法",
            "三轮简答 (75-105min)": "完成简答题，注意分点作答",
            "四轮检查 (105-120min)": "检查标记题+多选+计算题",
        }
        
        print("\n  📋 三轮检查策略：")
        for strategy, desc in strategies.items():
            print(f"     {strategy}: {desc}")
        print()


# ========== 使用示例 ==========
if __name__ == "__main__":
    # 创建时间分配器
    allocator = TimeAllocator(total_time=120)
    
    # 模拟：单选题做了30题，花了25分钟，标记了第7、15、28题
    allocator.record_progress(
        QuestionType.SINGLE_CHOICE, 
        completed=30, 
        time_spent=25, 
        marked=[7, 15, 28]
    )
    allocator.elapsed = 25
    
    # 打印当前状态
    allocator.print_dashboard()
    
    # 检查是否应该跳过某题
    should_skip, msg = allocator.should_skip(QuestionType.SINGLE_CHOICE, 55)
    print(f"  跳过建议：{'是' if should_skip else '否'} — {msg}")
    
    # 模拟答题策略
    allocator.simulate_strategy()

八、考试要点速记表格