Computational Thinking and Algorithms计算思维与算法

Decomposition.分解。 Break into sub-problems: (1) store the list of subjects and due dates; (2) sort tasks by urgency; (3) display the prioritised list; (4) mark tasks complete. Each is now small enough to code independently.拆分为子问题：(1) 存储学科列表和截止日期；(2) 按紧迫性排序任务；(3) 显示优先列表；(4) 标记任务为已完成。每个子问题现在都足够小，可以独立编码。

Pattern recognition.模式识别。 Sorting tasks by date is the same pattern as sorting any list of items by a key — you can reuse a general sorting approach (covered in the Searching and Sorting guide).按日期排序任务与按键排序任何项目列表的模式相同——你可以重复使用通用排序方法（在搜索与排序指南中介绍）。

Abstraction.抽象。 Represent each task as a record with just three fields: subject, due_date, done. Ignore everything else (teacher name, room number, textbook page) — it is irrelevant to the scheduling problem.将每个任务表示为只有三个字段的记录：subject（学科）、due_date（截止日期）、done（完成状态）。忽略其他一切（教师姓名、教室编号、课本页码）——它们与调度问题无关。

Algorithmic thinking.算法思维。 Write the steps in pseudocode: INPUT tasks with due dates → SORT tasks by due date → FOR EACH task: DISPLAY subject and date → END. Each step is unambiguous and executable.用伪代码写出步骤：输入带截止日期的任务 → 按截止日期排序任务 → 对每个任务：显示学科和日期 → 结束。每个步骤都是无歧义且可执行的。

Algorithm in pseudocode.算法（伪代码）。

INPUT amount
SET count TO 0
FOR EACH coin IN [25, 10, 5, 1]:
    WHILE amount >= coin:
        SET amount TO amount - coin
        SET count TO count + 1
OUTPUT count

In the pseudocode above: INPUT reads a value; SET ... TO assigns a value; FOR EACH iterates over each element; WHILE repeats while a condition holds; OUTPUT prints a result.以上伪代码中：INPUT 输入，SET ... TO 赋值，FOR EACH 对每个，WHILE 当…时，OUTPUT 输出。

Python rendering.Python 实现。

def min_coins(amount):
    count = 0
    for coin in [25, 10, 5, 1]:
        while amount >= coin:
            amount -= coin
            count += 1
    return count

print(min_coins(87))  # Output: 6

The pseudocode maps directly to Python: each keyword has a near-identical Python counterpart. Writing pseudocode first means the Python almost writes itself. Output: 87 = 3×25 + 1×10 + 2×1 = 6 coins.伪代码直接映射到 Python：每个关键字都有近乎相同的 Python 对应物。先写伪代码意味着 Python 几乎会自动写出。输出：87 = 3×25 + 1×10 + 2×1 = 6 枚硬币。

Pseudocode first (always write this before the flowchart).先写伪代码（总是在画流程图之前写这个）。

START
INPUT score
IF score >= 90 THEN
    OUTPUT "A"
ELSE IF score >= 80 THEN
    OUTPUT "B"
ELSE
    OUTPUT "C or below"
END IF
END

Flowchart structure (described textually).流程图结构（文字描述）。

Oval "START" → Parallelogram "Read score" → Diamond "score ≥ 90?" → YES branch: Parallelogram "Output A" → Oval "END". NO branch → Diamond "score ≥ 80?" → YES branch: Parallelogram "Output B" → Oval "END". NO branch → Parallelogram "Output C or below" → Oval "END". Notice: three possible END ovals (or alternatively one shared END after merging the branches).椭圆"开始"→ 平行四边形"读取分数"→ 菱形"分数 ≥ 90？"→ 是分支：平行四边形"输出 A"→ 椭圆"结束"。否分支 → 菱形"分数 ≥ 80？"→ 是分支：平行四边形"输出 B"→ 椭圆"结束"。否分支 → 平行四边形"输出 C 或以下"→ 椭圆"结束"。注意：三个可能的结束椭圆（或者在合并分支后共享一个结束）。

IPO analysis first.首先进行 IPO 分析。

• Input: Celsius temperature (a number).输入：摄氏温度（一个数字）。
• Process: multiply by 9, divide by 5, add 32.处理：乘以 9，除以 5，加 32。
• Output: Fahrenheit temperature.输出：华氏温度。

Pseudocode.伪代码。

INPUT celsius
SET fahrenheit TO (celsius * 9 / 5) + 32
OUTPUT fahrenheit

Python.Python。

celsius = float(input("Enter Celsius: "))
fahrenheit = (celsius * 9 / 5) + 32
print(f"{celsius}°C = {fahrenheit}°F")

Notice: three lines, three phases. The order is critical — you must have the Celsius value before you can compute Fahrenheit; you must have Fahrenheit before you can output it. Swapping lines 1 and 2 causes an error.注意：三行，三个阶段。顺序至关重要——在计算华氏度之前必须有摄氏度值；在输出之前必须有华氏度。交换第 1 行和第 2 行会导致错误。

Linear search (check index 0, 1, 2, … until found).线性搜索（检查索引 0、1、2……直到找到）。

91 at index 13 → checked indices 0-13 → 14 steps

Binary search (list has 16 items; indices 0–15).二分搜索（列表有 16 项；索引 0–15）。

Step 1: mid = 7 → list[7] = 42. 91 > 42 → search upper half [8..15]
Step 2: mid = 11 → list[11] = 80. 91 > 80 → search upper half [12..15]
Step 3: mid = 13 → list[13] = 91. FOUND! → 3 steps

Linear: 14 steps. Binary: 3 steps. For 16 items, log₂(16) = 4 (upper bound), and we did it in 3. Binary search is dramatically more efficient on sorted data, but requires the list to be sorted first.线性：14 步。二分：3 步。对于 16 项，log₂(16) = 4（上界），我们在 3 步内完成。二分搜索在已排序数据上效率显著更高，但需要先对列表排序。

Level 1 — overall problem.第 1 级——整体问题。 Read 5 scores → compute average → determine letter grade → output.读取 5 个成绩 → 计算平均分 → 确定字母等级 → 输出。

Level 2 — four sub-problems.第 2 级——四个子问题。

• Sub-problem A: Read 5 scores from the user.子问题 A：从用户读取 5 个成绩。
• Sub-problem B: Compute the average of the 5 scores.子问题 B：计算 5 个成绩的平均值。
• Sub-problem C: Map the average to a letter grade.子问题 C：将平均值映射到字母等级。
• Sub-problem D: Output the average and the grade.子问题 D：输出平均分和等级。

Pseudocode (one sub-problem at a time).伪代码（每次一个子问题）。

-- Sub-problem A: Read scores
SET total TO 0
FOR i FROM 1 TO 5:
    INPUT score
    SET total TO total + score

-- Sub-problem B: Compute average
SET average TO total / 5

-- Sub-problem C: Determine grade
IF average >= 90 THEN SET grade TO "A"
ELSE IF average >= 80 THEN SET grade TO "B"
ELSE IF average >= 70 THEN SET grade TO "C"
ELSE IF average >= 60 THEN SET grade TO "D"
ELSE SET grade TO "F"

-- Sub-problem D: Output
OUTPUT average, grade

Each sub-problem is now a small, independent piece of pseudocode. You can test each part separately before combining them. This is the core benefit of decomposition: independently testable units.每个子问题现在是一小段独立的伪代码。你可以在合并之前分别测试每个部分。这是分解的核心好处：可独立测试的单元。

Buggy pseudocode.有错误的伪代码。

SET total TO 0
SET i TO 1
WHILE i < 5:
    SET total TO total + i
    SET i TO i + 1
OUTPUT total

Trace table (variable: i, total).追踪表（变量：i，total）。

Bug found.找到错误。 Output is 10, not 15. The condition i < 5 stops the loop before adding 5. Fix: change to i <= 5 (or equivalently i < 6). This is a classic off-by-one logic error.输出是 10，不是 15。条件 i < 5 在添加 5 之前停止了循环。修复：改为 i <= 5（或等价地 i < 6）。这是经典的"差一"逻辑错误。