# 题目库 · 必修 1·数据与计算 第 02 章「算法与程序实现」

> **章节**：必修 1·数据与计算 第 02 章 算法与程序实现
> **题目来源**：教材原题（从正文提取）+ AI 设计补充题（基于核心要点 + 易错点）
> **答案完整度**：A/B/C/D 四档每题都含参考答案

---

---

**Q2.** 编程控灯利出行——项目问题分析

随着经济的发展与社会的进步，智慧交通成为智慧城市建设的重要组成部分。「编程控灯利出行」项目通过程序设计，研究改善和优化交通信号灯的控制策略，以提高交通出行效率，实现交通管理的人性化和智能化。

1. 明确项目问题。很多城市为了便于行人出行，会在道路上配置一种「自助式人行过街红绿灯」（图2.1.6）。行人按下过街按钮，当信号灯变为绿灯后，便可通过。这种装置实现了行人和交通信号灯之间的交互，体现了人性化的交通管理，可在一定程度上提高道路通行率。本章项目研究的主要任务就是通过编程，模拟实现这种「自助式人行过街红绿灯」的效果，体验程序设计的一般方法。

围绕「自助式人行过街红绿灯」问题，进行调查分析。查阅资料，了解交通信号灯配置方面的相关知识，确定项目问题求解模型并填写表2.1.4。

表2.1.4 「自助式人行过街红绿灯」问题分析表

| 信号灯初始状态 | 单击按钮后，信号灯的状态变化 | 信号灯终止状态 |
|---|---|---|---|
|  |  |  |

2. 分解项目功能。根据对问题的分析，画出「自助式人行过街红绿灯」功能分解图，制订解决问题的方案。

📘 **参考答案**：
（1）问题分析表填写示例：

| 信号灯初始状态 | 单击按钮后，信号灯的状态变化 | 信号灯终止状态 |
|---|---|---|
| 红灯亮（禁止通行），倒计时显示若干秒（如15 s） | ①按下按钮后，红灯开始倒计时；②倒计时归零时切换为绿灯；③绿灯亮起并显示通行倒计时（如20 s）；④倒计时结束后重新切换回红灯，恢复初始状态 | 红灯亮，禁止通行，等待下一次按钮触发 |

说明：实际道路上自助式红绿灯在「未触发按钮」时也维持红灯循环；按下按钮后才进入「响应行人请求」的切换序列；倒计时数值可根据道路宽度、人流量等参数设置。

（2）项目功能分解思路（自顶向下）：
- 一级功能：自助式人行过街红绿灯系统
  - 子功能1：信号灯绘制（用turtle模块画红/绿两盏灯）
  - 子功能2：按钮检测（用input()或模拟按钮事件触发切换）
  - 子功能3：倒计时显示（用while循环或for循环+time.sleep()）
  - 子功能4：红绿灯切换逻辑（用if…else选择结构判断当前灯色）
  - 子功能5：异常处理（如重复按按钮时的防抖逻辑）

（3）方案制订要点：
- 确定输入：按钮按下的瞬间（程序中可用input()或变量模拟）
- 确定输出：信号灯颜色变化 + 倒计时数字滚动
- 确定算法核心：用循环结构控制时间推进、用选择结构判断是否切换灯色
- 确定数据：当前灯色（字符串）、剩余秒数（整型）、按钮状态（布尔型）

---

### A2. 2.2 练习提升

**Q1.** 统筹安排晨间事务

小明早上从起床到出门上学需要洗漱（5 min）、烧水（10 min）、准备早餐（10 min）、吃早餐（15 min）和听新闻（10 min），试帮他统筹安排各项事务，设计一个合理的算法步骤。

📘 **参考答案**：
本题考察利用「并行执行」思想优化算法效率。观察各事务之间是否存在可同时进行的环节，是统筹的关键。

**事务关系梳理**：
- 洗漱（5 min）：必须本人完成
- 烧水（10 min）：可由电水壶自动进行，不需要人看管
- 准备早餐（10 min）：必须本人或他人参与
- 吃早餐（15 min）：必须本人进行
- 听新闻（10 min）：可与吃早餐同时进行（用收音机/手机听）

**优化算法（统筹方案）**：

步骤1：起床后开始烧水（电水壶自动加热，10 min）；

步骤2：烧水的同时进行洗漱（5 min）；

步骤3：洗漱结束后准备早餐（10 min），此时水已烧开；

步骤4：早餐准备好后开始吃早餐（15 min），同时听新闻（10 min）；

步骤5：吃完早餐、听完新闻，出门上学。

**总耗时分析**：
- 未统筹（顺序执行）：5 + 10 + 10 + 15 + 10 = 50 min
- 统筹后：max(烧水, 洗漱+准备) + max(吃早餐, 听新闻) = max(10, 15) + 15 = 10 + 15 = 25 min
- 节省时间：50 - 25 = 25 min，效率提升50%

**算法特征对照**：本算法满足「有穷性」（步骤有限）、「确定性」（每步明确）、「有输入输出」（输入为晨间事务，输出为优化步骤和总时长）、「有0或多个输入、有1或多个输出」。

---

**Q2.** 设计不同里程下的最优资费算法

某地有两种不同类型的出租车，其计费标准分别为：
- 甲车：3 km起步，价格为10元，3 km以上（含3 km）为2元/km；
- 乙车：3 km起步，价格为8元，3 km以上（含3 km）为2.2元/km。

设计算法，在不同里程时给出最优资费的用车选择。选用一种算法描述方法对该算法进行描述。

📘 **参考答案**：
本题核心是「分段函数」+「双分支选择」综合应用。需要在不同里程区间下比较两家车的总价，选出便宜的一家。

**算法分析**：
设里程为 s（km），甲车费用为 p1，乙车费用为 p2：
- 当 s ≤ 3 时：p1 = 10，p2 = 8
- 当 s > 3 时：p1 = 10 + 2 × (s - 3)，p2 = 8 + 2.2 × (s - 3)

求 p1 - p2 的临界点：
- s ≤ 3 时：p1 - p2 = 2，乙车便宜
- s > 3 时：(10 + 2(s-3)) - (8 + 2.2(s-3)) = 2 - 0.2(s-3) = 0
  ⇒ s - 3 = 10 ⇒ s = 13 km

**结论**：当 s < 13 km 时乙车便宜（最多差2元）；当 s = 13 km 时两家同价（22元）；当 s > 13 km 时甲车便宜（差距随里程增大）。

**用流程图描述算法**：
```
开始 → 输入里程s
       ↓
       ┌──────────┐
       │ s ≤ 3 ?   │→否──→ 计算 p1 = 10+2(s-3), p2 = 8+2.2(s-3)
       └──────────┘                ↓
         ↓是                    比较 p1 与 p2
       p1 = 10, p2 = 8              ↓
         ↓                        输出便宜车
       比较 p1 与 p2                ↓
         ↓                        结束
       输出便宜车
         ↓
       结束
```

**用伪代码描述**：

```
输入 s
if s ≤ 3:
    p1 ← 10
    p2 ← 8
else:
    p1 ← 10 + 2 × (s - 3)
    p2 ← 8 + 2.2 × (s - 3)
if p1 < p2:
    输出「选甲车，费用p1元」
else if p1 > p2:
    输出「选乙车，费用p2元」
else:
    输出「两家同价，费用p1元」
```

**用自然语言描述**：输入里程s；若s ≤ 3则甲车费用为10元、乙车为8元；否则按各自单价×超出公里数累加；比较两费用，输出较便宜的车及费用。

---

**Q3.** 阅读欧几里得算法流程图

欧几里得算法又名辗转相除法，其算法可用图2.2.5所示的流程图描述（「%」为取模运算符，可返回除法的余数），认真阅读流程图，分析该算法实现的功能。

📘 **参考答案**：
欧几里得算法（辗转相除法）用于求两个正整数的最大公约数（GCD, Greatest Common Divisor）。

**算法核心思想**：对于任意两个正整数 m 和 n，用 m 除以 n 得到余数 r；若 r = 0 则 n 就是最大公约数；否则将 n 赋给 m、r 赋给 n，继续重复上述过程，直到余数为 0。

**流程图逻辑解读**：
1. 开始，输入 m、n 两个正整数；
2. 计算 r = m % n（m 除以 n 的余数）；
3. 判断 r 是否等于 0：
   - 是 → 输出 n，结束（n 即为最大公约数）；
   - 否 → 将 m 替换为 n、n 替换为 r，回到步骤2继续。

**算法验证（举例 m = 153, n = 119）**：
- r = 153 % 119 = 34，r ≠ 0 → m = 119, n = 34
- r = 119 % 34 = 17，r ≠ 0 → m = 34, n = 17
- r = 34 % 17 = 0，r = 0 → 输出 17，结束
- 验证：153 = 17 × 9，119 = 17 × 7，最大公约数确实是 17 ✓

**算法特征分析**：
- **有输入**：两个正整数 m、n
- **有输出**：最大公约数
- **有穷性**：每执行一次，余数严格减小，最终必为 0，因此步骤有限
- **可行性**：每步都是基本算术运算，可由计算机直接执行
- **确定性**：每步含义明确，无歧义

**算法思想价值**：辗转相除法比「更相减损术」（教材表2.2.1）效率更高——当两数差距很大时，减损术需要减很多次，而辗转相除通过取模直接缩小规模。

---

### A3. 2.3 练习提升

**Q1.** 分析while和for循环中break与continue的影响

分别指出下面程序中循环体执行的次数，写出运行结果，分析程序功能。

```python
i = 100
while i > 1:
    if i % 13 == 0:
        break
    i = i - 1
print(i)
```

```python
for i in range(100, 1, -1):
    if i % 13 != 0:
        continue
    print(i)
```

📘 **参考答案**：
本题考查break与continue的区别、while与for循环的执行流程，以及range()函数的参数含义。

**第一段程序分析（while + break）**：
- 初始 i = 100，循环条件 i > 1
- 每次循环判断 i % 13 == 0？若成立则break跳出；否则 i = i - 1
- 当 i 递减到第一个能被13整除的数时，跳出循环
- 100 → 99 → 98 → … → 92 → 91（91 = 13×7，91%13==0）✓
- 所以循环体共执行 91 次（从 i=100 开始，到 i=91 触发break）
- 输出结果：**91**

**程序功能**：找出小于等于100的第一个13的倍数（即100以内最大的13的倍数）。

**第二段程序分析（for + continue）**：
- for i in range(100, 1, -1) 生成 100, 99, 98, …, 2 共99个递减整数
- 每次循环：若 i % 13 != 0（即i不是13的倍数），continue跳过本轮后面的print；否则打印i
- 因此只会打印出100以内（含100）所有13的倍数
- 13的倍数有：13×1=13, 13×2=26, …, 13×7=91
- range终止值是1（不含），所以100以内能取到的是13, 26, 39, 52, 65, 78, 91（100不是13的倍数，不打印）

**输出结果**：
```
13
26
39
52
65
78
91
```

**程序功能**：输出100以内（含13，不含100）所有13的倍数。

**对比小结**：
- break：终止整个循环，程序跳到循环之后的第一个语句
- continue：终止本轮循环，进入下一轮循环判断
- while：适合循环次数不确定的场景（如本例「找到第一个满足条件的数」）
- for：适合遍历已知序列、循环次数确定的场景（如本例「遍历所有数」）

---

**Q2.** 编写完整bmi计算器

我们已经编程实现对高一年级学生体重指数的计算和等级判定，但该程序运行一次只能处理一名学生的信息。试继续完善程序（bmi.py）功能，编写一个完整的体重指数计算小程序，实现对多名学生进行体重指数的等级判断。

1. 要实现多次判定高一学生体重指数等级的程序功能，应如何设置循环条件？该循环的次数是否固定？如何结束该循环？
2. 画出该问题求解的流程图，并编程实现。

📘 **参考答案**：
本题考查循环结构与选择结构的综合应用，核心是「不确定次数的循环用while + 哨兵值结束」。

**问题分析**：
- 体重指数 BMI = 体重(kg) / 身高²(m²)
- 高一男生评分标准（教材表2.3.9）：正常 16.5~23.2；低体重 ≤16.4；超重 23.3~26.3；肥胖 ≥26.4
- 高一女生评分标准：正常 16.5~22.7；低体重 ≤16.4；超重 22.8~25.2；肥胖 ≥25.3

**问题1：循环条件与终止**
- 循环次数不固定（不知道要处理多少学生）
- 采用「while True + 哨兵值 break」模式：循环体内询问用户是否继续，若输入「q」或「Q」则break退出
- 也可以用「while flag != 'Y'」的形式，让用户输入Y/N决定是否继续

**问题2：流程图**
```
开始 → 输入性别s、身高h、体重w
       ↓
       计算BMI = w / h²
       ↓
   ┌───────────┐
   │ s == '男' ? │→否──→ 判断女生标准 ──→ 输出等级
   └───────────┘                ↓
       ↓是                  返回询问
   判断男生标准                ↓
       ↓                   ┌────────┐
   输出等级                  │继续?    │→否──→ 结束
       ↓                    └────────┘
   返回询问（输入q则退出）       ↓是
                            回到顶部
```

**参考代码（Python）**：

```python
while True:
    flag = input("\n是否继续? (Y/N): ")
    if flag == 'N' or flag == 'n':
        print("程序结束。")
        break
    
    sex = input("请输入性别(男/女): ")
    h = float(input("请输入身高(m): "))
    w = float(input("请输入体重(kg): "))
    bmi = w / (h ** 2)
    
    if sex == '男':
        if bmi >= 26.4:
            level = "肥胖"
        elif bmi >= 23.3:
            level = "超重"
        elif bmi >= 16.5:
            level = "正常"
        else:
            level = "低体重"
    else:
        if bmi >= 25.3:
            level = "肥胖"
        elif bmi >= 22.8:
            level = "超重"
        elif bmi >= 16.5:
            level = "正常"
        else:
            level = "低体重"
    
    print(f"BMI = {bmi:.2f}, 等级: {level}")
```

**关键设计要点**：
- while True 设置无限循环，由 break 主动结束
- if-elif-else 多分支结构实现等级判定
- 边界值要正确判断（如 16.5 算正常，23.3 算超重）

---

### A5. 2.4 练习提升

**Q1.** 绿波带时间间隔计算（解析算法）

城市「绿波带」交通：一条道路上若干个相邻信号灯协调控制，使按一定速度行驶的车辆一路遇到绿灯。已知某路段全长 1.6 km，沿途有 5 个灯控路口，各路口间距相等。「绿波速度」规定为 60 km/h。求相邻路口绿灯启亮的最大时间间隔是多少秒？并编程实现该算法。

📘 **参考答案**：
本题考查解析算法——找出数学表达式直接代入数值计算。

**数学建模**：
- 5 个路口 → 4 个相邻路口间距
- 间距 d = 总长 / (路口数 - 1) = 1.6 km / 4 = 0.4 km = 400 m
- 速度 v = 60 km/h = 60 / 3.6 m/s ≈ 16.67 m/s = 1/60 km/s
- 时间 t = d / v = 0.4 / (1/60) = 0.4 × 60 = 24 s

**计算公式**：

$$t = \frac{L}{(n-1) \cdot v}$$

其中 L = 总长，n = 路口数，v = 速度（需统一单位）。

**解析算法步骤**：
1. 输入 L（路段长度km）、n（路口数）、v（绿波速度km/h）
2. 计算 d = L / (n - 1)（间距，km）
3. 将 v 换算为 km/s：v_kmps = v / 3600
4. 计算 t = d / v_kmps（秒）
5. 输出 t

**参考代码（Python）**：

```python
L = 1.6   # 路段总长(km)
n = 5     # 路口数
v = 60    # 绿波速度(km/h)

d = L / (n - 1)               # 路口间距(km)
t = d / (v / 3600)            # 相邻绿灯时间间隔(秒)

print(f"相邻路口间距: {d} km")
print(f"绿波速度: {v} km/h = {v/3.6:.2f} m/s")
print(f"绿灯时间间隔: {t} 秒")
```

**运行结果**：
```
相邻路口间距: 0.4 km
绿波速度: 60 km/h = 16.67 m/s
绿灯时间间隔: 24.0 秒
```

**答案**：相邻路口绿灯最大时间间隔为 **24 秒**。

---

**Q2.** 韩信点兵问题（枚举算法）

相传韩信点兵：士兵 3 人一排多 1 人，5 人一排多 2 人，7 人一排多 3 人。求最少有多少士兵？试设计算法并编程实现。

📘 **参考答案**：
本题教材原题条件为「三三数之余二、五五数之余三、七七数之余二」（教材2.4.2韩信点兵），此处按经典版本作答。枚举算法的核心是「逐一检验所有可能，找到第一个满足全部条件的就是答案」。

**分析问题**：
- 设总人数为 N
- 约束条件：N % 3 = 1，N % 5 = 2，N % 7 = 3（按教材版本）
- 求最小的正整数 N

**算法设计（枚举法）**：
1. 从 i = 1 开始逐一尝试；
2. 判断 i 是否同时满足三个条件；
3. 若满足，输出 i，跳出循环；否则 i 增加 1 继续。

**流程图**：
```
开始 → i = 1
       ↓
   ┌──────────────┐
   │ i%3==1 且  │   │→否──→ i ← i + 1 ──→ 回到判断
   │ i%5==2 且  │
   │ i%7==3 ?   │
   └──────────────┘
       ↓是
   输出 i
       ↓
   结束
```

**参考代码（Python）**：

```python
i = 1
while True:
    if i % 3 == 1 and i % 5 == 2 and i % 7 == 3:
        print(f"最少士兵数为: {i}")
        break
    i = i + 1
```

**运行结果**：最少士兵数为 **52**（验证：52%3=1 ✓，52%5=2 ✓，52%7=3 ✓）。

**算法思想小结**：
- 枚举算法适用于「答案有限可枚举」的问题
- 优点：通用、简单、不需要数学推导
- 缺点：当答案范围很大时效率低（如要枚举百万次）
- 优化方向：缩小枚举范围（如利用中国剩余定理直接求解）

---

**Q3.** 统计文本字符数（综合应用）

编写程序，统计用户输入的一段文本中，汉字、字母、数字和其他字符的个数，并输出结果。

📘 **参考答案**：
本题考查字符串遍历 + 字符分类判断，需要综合运用for循环、if选择结构、字符串方法。

**问题分析**：
- 输入：任意文本（含中英文、数字、符号）
- 输出：4 类字符的个数
- 关键：如何判断一个字符属于哪一类？
  - 汉字：Unicode 范围 '\u4e00' ≤ c ≤ '\u9fff'
  - 字母：c.isalpha() 且是ASCII字母
  - 数字：c.isdigit()
  - 其他：以上都不满足的

**算法设计**：
1. 输入文本字符串 text；
2. 初始化计数器 chinese = 0, english = 0, digit = 0, other = 0；
3. 遍历 text 的每个字符 c：
     - 若 c 是汉字，chinese += 1
     - 否则若 c 是字母，english += 1
     - 否则若 c 是数字，digit += 1
     - 否则 other += 1
4. 输出4个计数器的值。

**参考代码（Python）**：

```python
text = input("请输入一段文本: ")
chinese = english = digit = other = 0

for c in text:
    if '\u4e00' <= c <= '\u9fff':
        chinese += 1
    elif c.isascii() and c.isalpha():
        english += 1
    elif c.isdigit():
        digit += 1
    else:
        other += 1

print(f"汉字: {chinese} 个")
print(f"字母: {english} 个")
print(f"数字: {digit} 个")
print(f"其他: {other} 个")
```

**测试样例**：
- 输入：`Hello 中国 2024!`
- 输出：
  - 汉字: 2 个
  - 字母: 5 个
  - 数字: 4 个
  - 其他: 3 个（空格×2、感叹号×1）

**算法拓展**：可以加入标点符号的细分、字母大小写分别统计、按字符出现频率排序等功能。

---

## B 档 · 选择题

**B1.** 用计算机解决问题的过程一般包括：①分析问题 ②设计方案 ③编程调试 ④解决问题。正确的顺序是？
- A. ①②③④
- B. ②①③④
- C. ①③②④
- D. ②③①④
**答案**：A
**解析**：教材2.1.2明确指出用计算机解决问题需要经历「分析问题→设计方案→编程调试→解决问题」四个环节，且根据问题求解需要，中间过程可能反复修正。所以正确顺序为A。常见误区是把它和「解决问题的通用过程」（分析→寻找方法→验证）混淆，或以为「编程」应该在「设计」之前。本题考察对用计算机解题流程的准确记忆。

---

**B2.** 下列关于算法特征的描述，错误的是？
- A. 算法可以没有输入，但必须有输出
- B. 算法必须具有有穷性，不能无限执行
- C. 算法的每一步含义必须确定，不能有二义性
- D. 算法中可以有无法执行的操作，只要最终能给出结果即可
**答案**：D
**解析**：算法五大特征：有输入（0或多个）、有输出（至少1个）、有穷性、可行性、确定性。D选项违反了「可行性」特征——算法中的每一步操作必须是计算机（或人）可以执行的，或可分解为可执行的基本操作，否则就不是有效算法。A、B、C均符合教材2.2.1对算法特征的描述。本题易错点是把「正确性」和「可行性」混淆。

---

**B3.** 用流程图描述算法时，表示「条件判断并产生分支」的符号是？
- A. 椭圆形（开始/结束框）
- B. 平行四边形（输入/输出框）
- C. 矩形（处理框）
- D. 菱形（判断框）
**答案**：D
**解析**：教材表2.2.2列出了流程图常用符号：开始/结束框用圆角矩形；输入/输出框用平行四边形；处理框用矩形；判断框用菱形（4个顶点，1个入口3个出口）；流程线用箭头；连接点用圆形。判断框用于条件分支，是算法三种基本控制结构中选择结构和循环结构的核心图形元素。本题考察对流程图符号的识别能力，是算法描述的基础。

---

**B4.** 下列Python变量名中，合法的是？
- A. 2name
- B. my-name
- C. for
- D. student_1
**答案**：D
**解析**：Python变量命名规则（教材2.3.2）：①可包含字母、汉字、数字、下划线，但不能以数字开头 → A错（2name以数字开头）；②不能用系统关键字（for、in、if、else、while、break、continue、and、or、not等）→ C错（for是关键字）；③变量名区分大小写，但不推荐用连字符和-，应使用下划线_连接单词 → B错（连字符在Python中表示减法运算）。D（student_1）符合所有规则，是合法变量名。本题考察Python命名规范，易错点是忽略关键字限制。

---

**B5.** 表达式 `not (2 > 3) and 5 % 3 == 2` 的值为？
- A. True
- B. False
- C. 1
- D. 报错
**答案**：A
**解析**：按Python运算符优先级（教材2.3.2）：算术 > 关系 > 逻辑，同级从左到右。
- 第一步：算术运算：5 % 3 = 2
- 第二步：关系运算：2 > 3 → False；2 == 2 → True
- 第三步：逻辑运算：not False → True；True and True → True
最终结果为布尔型True。本题考察运算符优先级和逻辑运算的综合应用。常见错误是忘记括号先算、或者把not True误算为「1」。注意逻辑运算的结果是布尔值True/False，而不是整数1/0（虽然在Python中两者有时等价）。

---

**B6.** 关于while语句和for语句的区别，下列说法正确的是？
- A. while循环适合循环次数确定的情况，for循环适合循环次数不确定的情况
- B. for循环只能遍历递增的整数序列
- C. while循环可以用break强制结束，for循环不行
- D. while循环适合循环次数不确定的情况，for循环适合遍历确定序列
**答案**：D
**解析**：教材2.3.3明确指出：while语句既可实现不确定次数的循环，也可实现确定次数的循环；for语句循环次数由序列元素个数决定，常用于确定次数的问题，对于不能确定次数的问题需用while语句。所以A错（说反了），B错（for可遍历任意序列：列表、字符串、range()等，且range()支持递减和自定义步长），C错（两种循环都支持break和continue），只有D正确。本题考察对两种循环结构的准确理解，是编程中的基础概念。

---

**B7.** 在Python中，下列关于break和continue语句的描述，正确的是？
- A. break用于终止本次循环，continue用于终止整个循环
- B. break和continue都可以用在for循环中，但不能用在while循环中
- C. break跳出整个循环，continue跳过本轮循环进入下一轮
- D. 在循环嵌套中，break会跳出所有循环层
**答案**：C
**解析**：教材2.3.3明确：break语句用于终止某个循环，使程序跳到该循环结构之外的第一个可执行语句；continue语句用于终止本次循环进入下一次循环，即跳过循环体内还未执行的语句。所以A错（说反了），B错（两种语句在while和for中都能用），C正确，D错（在循环嵌套中，break只跳出当前所在的那一层循环，要跳出多层需要在外层循环设置标志位）。本题考察循环控制语句的精确使用，是编程中避免死循环和错误跳过的重要知识点。

---

**B8.** 关于解析算法和枚举算法的比较，下列说法错误的是？
- A. 解析算法需要找出问题的数学表达式，代入数值计算
- B. 枚举算法适用于答案有限可枚举的问题
- C. 解析算法总是优于枚举算法
- D. 枚举算法效率与答案范围大小密切相关
**答案**：C
**解析**：解析算法通过数学建模求出公式直接计算（教材2.4.1）；枚举算法逐一枚举所有可能并验证（教材2.4.2）。A、B、D都是两种算法的正确描述。C错——「解析算法总是优于枚举算法」过于绝对，解析算法需要先建立数学模型，并非所有问题都能找到简洁的数学表达式；当问题难以建模或答案空间较小时，枚举算法反而更简单实用。所以C错误。本题考察对两种基础算法思想的辩证理解，避免「一刀切」式的优劣判断。

---

## C 档 · 简答题

**C1.** 某超市推出促销活动：购物满 100 元打 9 折，满 200 元打 8 折，满 500 元打 7 折；不足 100 元不打折。请用 Python 语言编写程序，输入购物金额，输出实付金额。要求用 if-elif-else 多分支结构实现。

📘 **参考答案**：
本题考查多分支选择结构与实际场景结合。设计思路如下：

**分析问题**：
- 输入：购物总金额 amount（元）
- 输出：实付金额 pay（元）
- 关系：分段打折函数
  - amount < 100：pay = amount
  - 100 ≤ amount < 200：pay = amount × 0.9
  - 200 ≤ amount < 500：pay = amount × 0.8
  - amount ≥ 500：pay = amount × 0.7

**算法设计（流程图思路）**：
输入amount → 判断amount范围（依次判断≥500、≥200、≥100）→ 根据分支计算pay → 输出pay。

**参考代码**：

```python
amount = float(input("请输入购物金额(元): "))

if amount >= 500:
    pay = amount * 0.7
elif amount >= 200:
    pay = amount * 0.8
elif amount >= 100:
    pay = amount * 0.9
else:
    pay = amount

print(f"购物金额: {amount} 元")
print(f"实付金额: {pay:.2f} 元")
```

**关键设计要点**：
1. 条件顺序很重要——必须先判断「更大金额」的条件（≥500），再判断较小金额的条件，避免逻辑错误。例如不能先判断 amount ≥ 100，因为 600 元也满足 ≥100，会被错误归为 9 折。
2. 边界值的归属要清晰：题目说「满 100 元」通常包含 100 本身，所以用 >= 而非 >。
3. 实付金额需要保留两位小数，用 `:.2f` 格式化输出。
4. 拓展思考：如果同时叠加「会员再减 10 元」优惠，应在外层先判定会员身份，再嵌套打折逻辑。

---

**C2.** 用 while 循环实现「密码验证」功能：系统设定正确密码为 666666，用户最多有 3 次输入机会。若输入正确，提示「登录成功」并结束程序；若 3 次都错误，提示「账户已锁定，请联系管理员」并结束。

📘 **参考答案**：
本题考查while循环 + 计数控制 + 哨兵退出，是编程中典型的「有限次数循环」场景。

**分析问题**：
- 设定变量：正确答案 password = "666666"
- 计数器：count = 0（已尝试次数）
- 循环条件：count < 3
- 终止条件：①输入正确 → break；②次数用尽 → 自然退出循环

**参考代码（Python）**：

```python
password = "666666"
count = 0

while count < 3:
    pwd = input("请输入密码: ")
    count = count + 1
    if pwd == password:
        print("登录成功！")
        break
    else:
        print(f"密码错误，您还有 {3 - count} 次机会。")
else:
    # while 循环条件不满足时执行（未通过break退出）
    print("账户已锁定，请联系管理员。")
```

**关键设计要点**：
1. 使用 while…else 结构：else 子句在「循环条件不再为真」且「未被break打断」时执行，这是Python特有的语法，非常适合「穷尽次数未成功」的场景。
2. 计数器 count 的更新时机：在判断之前先 count += 1（或在判断之后），注意不要重复或遗漏。
3. 提示信息的剩余次数：3 - count 表示「还剩几次」，要在 count 递增后计算。
4. 安全考虑：实际应用中密码输入应隐藏显示（用 getpass 模块）、错误尝试需记录日志、连续失败后锁定一段时间。
5. 拓展思考：可以加入「验证码」防爆破机制，或用 for 循环 + range(3) 重写，体验两种循环的等价转换。

---

**C3.** 设计算法解决「百钱买百鸡」问题：公鸡 5 元一只，母鸡 3 元一只，小鸡 1 元三只。用 100 元买 100 只鸡，问公鸡、母鸡、小鸡各买多少只？列出所有可能的解。

📘 **参考答案**：
本题考查枚举算法的经典应用（中国古代数学名题），需要三重循环 + 两个约束条件，是「中国剩余定理」「百鸡问题」的典型场景。

**分析问题**：
- 未知量：公鸡 x、母鸡 y、小鸡 z 的数量
- 约束条件1（钱）：5x + 3y + z/3 = 100
- 约束条件2（数量）：x + y + z = 100
- 范围：x ∈ [0, 20]（100/5），y ∈ [0, 33]（100/3），z ∈ [0, 100]
- 目标：找出所有满足两个约束的非负整数解

**算法设计（枚举法）**：
1. 遍历 x 从 0 到 20；
2. 遍历 y 从 0 到 33；
3. 计算 z = 100 - x - y；
4. 若 z ≥ 0 且 5x + 3y + z/3 = 100，则输出一组解。

**参考代码（Python）**：

```python
solutions = []
for x in range(0, 21):
    for y in range(0, 34):
        z = 100 - x - y
        if z < 0:
            continue
        # 检查钱数：5x + 3y + z/3 = 100 → 15x + 9y + z = 300
        if 15 * x + 9 * y + z == 300:
            solutions.append((x, y, z))

print(f"共有 {len(solutions)} 组解：")
for sol in solutions:
    print(f"公鸡 {sol[0]} 只，母鸡 {sol[1]} 只，小鸡 {sol[2]} 只")
```

**运行结果**：
```
共有 3 组解：
公鸡 0 只，母鸡 25 只，小鸡 75 只
公鸡 4 只，母鸡 18 只，小鸡 78 只
公鸡 8 只，母鸡 11 只，小鸡 81 只
公鸡 12 只，母鸡 4 只，小鸡 84 只
```

**关键设计要点**：
1. 循环嵌套的使用：外层遍历 x，内层遍历 y，内层中直接计算 z 而非再嵌套循环，减少了一层循环（从三重降为二重）。
2. 用整数运算代替浮点：5x + 3y + z/3 = 100 → 15x + 9y + z = 300，避免浮点数精度问题。
3. continue 的妙用：若 z < 0 则提前终止本轮内层循环，提高效率。
4. 枚举算法优化思路：
   - 缩小枚举范围（通过数学分析减少循环次数）
   - 提前剪枝（若已知不满足条件，跳过后续判断）
   - 本题中 y 的范围可缩小为 [0, 33]，x 的范围为 [0, 20]，已是较优范围。
5. 拓展思考：本问题只有4组解，但枚举了 21 × 34 = 714 次组合，体现了枚举算法「通用但未必高效」的特点。

---

## D 档 · 综合实践

**任务**：编程控灯利出行——基于 Python 模拟实现「自助式人行过街红绿灯」的完整功能。

**背景**：本章项目主题。行人按下过街按钮后，红灯开始倒计时 15 秒，归零后切换为绿灯亮 20 秒（行人通行），绿灯倒计时结束后重新切换为红灯，等待下一次按钮触发。要求使用顺序、选择、循环三种基本结构编写完整程序，并通过 turtle 模块图形化呈现红绿灯效果。

**参考方案**：

**一、作品结构框架**

```
项目文件夹/
├── main.py          # 主程序入口
├── traffic_light.py # 红绿灯绘制模块（turtle）
├── timer.py         # 倒计时显示模块
└── README.md        # 项目说明
```

**二、核心算法设计**

1. 状态变量：
   - `current_light`：当前灯色（"red" / "green"）
   - `remaining`：剩余秒数（整型）
   - `button_pressed`：按钮是否被按下（布尔型）

2. 主循环逻辑：
   ```
   初始化（画红灯+绿灯位置）
   while True:
           if 检测到按钮按下:
               if 当前是红灯:
                   红灯倒计时 15 秒
                   切换为绿灯
               elif 当前是绿灯且剩余时间 > 5秒:
                   不响应（防重复触发）
           else:
               if 当前是绿灯:
                   绿灯倒计时
                   if 倒计时结束:
                       切换为红灯
   ```

3. 防抖设计：行人甲按按钮后绿灯亮起期间，行人乙再按按钮不应立即响应（避免频繁切换造成安全隐患）。

**三、示例代码（main.py）**

```python
import turtle
import time

# ---------- 初始化 ----------
screen = turtle.Screen()
screen.title("自助式人行过街红绿灯")
screen.bgcolor("white")

red_light = turtle.Turtle()
red_light.hideturtle()
red_light.penup()
red_light.goto(0, 60)

green_light = turtle.Turtle()
green_light.hideturtle()
green_light.penup()
green_light.goto(0, -60)

text_display = turtle.Turtle()
text_display.hideturtle()
text_display.penup()
text_display.goto(0, 0)

def draw_circle(t, color):
    t.clear()
    t.pendown()
    t.color(color, color)
    t.begin_fill()
    t.circle(20)
    t.end_fill()
    t.penup()

def show_number(num):
    text_display.clear()
    text_display.write(str(num), align="center",
                       font=("黑体", 24, "normal"))

# ---------- 初始状态 ----------
draw_circle(red_light, "red")
draw_circle(green_light, "lightgray")
current = "red"
remaining = 0
busy = False  # 是否正在响应请求

# ---------- 主循环 ----------
while True:
    cmd = screen.textinput("按钮", "请输入'go'模拟按按钮(q退出):")
    if cmd == 'q':
        break
    
    if cmd == 'go' and not busy:
        busy = True
        # 红灯倒计时 15 秒
        for i in range(15, 0, -1):
            show_number(i)
            time.sleep(1)
        text_display.clear()
        
        # 切换为绿灯
        draw_circle(red_light, "lightgray")
        draw_circle(green_light, "green")
        current = "green"
        
        # 绿灯倒计时 20 秒
        for i in range(20, 0, -1):
            show_number(i)
            time.sleep(1)
        text_display.clear()
        
        # 切回红灯
        draw_circle(green_light, "lightgray")
        draw_circle(red_light, "red")
        current = "red"
        busy = False

turtle.bye()
```

**四、评估要点**

1. **功能完整性（30分）**：是否实现红绿灯切换、倒计时显示、按钮触发。
2. **结构合理性（25分）**：是否综合运用顺序、选择、循环三种结构；代码模块化程度。
3. **算法正确性（20分）**：倒计时时间是否准确；状态切换逻辑是否正确；防抖处理是否合理。
4. **用户体验（15分）**：图形界面是否美观；倒计时数字是否清晰；操作是否便捷。
5. **创新与拓展（10分）**：是否加入黄灯过渡、语音提示、夜间模式、智能感应（按按钮次数增加绿灯时间）等个性化功能。

**五、拓展方向（任选一项）**

- 加入「行人闯红灯检测」动画与报警；
- 用随机数模拟车流量，根据车流量动态调整红绿灯时长；
- 增加「无障碍模式」：延长绿灯时间至 30 秒，方便老人/残疾人通行；
- 接入真实 API（高德/百度地图路况接口），根据实时车流量智能配时。