📚 CCEA Year 8 Computing: Case Study Practical Exercises | CCEA 八年级计算机：案例分析实战演练
In CCEA Year 8 Computing, case studies are a fantastic way to apply your computational thinking skills to real-world or imagined scenarios. A case study asks you to analyse a problem, break it down into manageable parts, design a solution, and then communicate that solution clearly — often using pseudocode or flowcharts. This article will guide you through a series of practical exercises that mirror the style of questions and activities you might face in class or in an assessment. By working through these examples, you will strengthen your ability to think like a computer scientist and approach new problems with confidence.
在 CCEA 八年级计算机课程中，案例分析是将计算思维技能应用于真实或虚拟场景的绝佳方式。一个案例分析会要求你分析问题，将其分解为可管理的部分，设计解决方案，然后清晰地呈现该方案——通常会用到伪代码或流程图。本文将通过一系列实战演练，带你体验课堂或测试中可能出现的题型和活动。通过这些例子，你将增强像计算机科学家一样思考的能力，并自信地应对新问题。
1. What Is a Case Study in Computing? | 计算机科学中的案例分析是什么？
A case study in computing is a narrative or scenario that presents a particular problem needing a digital solution. You are expected to examine the scenario, identify the key requirements, and then develop a structured plan. Unlike simple programming exercises that focus purely on code, a case study often includes systems analysis, user needs, data handling, and a design phase. In Year 8, the emphasis is on learning a systematic approach: understand, decompose, abstract, design, and evaluate.
在计算机科学中，案例分析是一种叙述或场景，呈现了某个需要数字解决方案的问题。你需要审视该场景，识别关键需求，然后制定一个结构化的计划。与单纯关注代码的编程练习不同，案例分析通常包含系统分析、用户需求、数据处理和设计阶段。在八年级，重点是学习一种系统性的方法：理解、分解、抽象、设计和评估。
When you encounter a case study, your first task is not to start coding immediately but to ask questions: Who will use this solution? What data is available? What must the output look like? This reflective, step‑by‑step mindset is at the heart of computational thinking. The practical exercises in this article are designed to build that muscle memory so that you can tackle any case study with a clear head.
当你遇到一个案例分析时，首要任务不是立刻写代码，而是提问：谁会使用这个方案？有哪些数据？输出应该是什么样子？这种反思性的、一步一步的思维方式正是计算思维的核心。本文中的实战演练旨在培养这种肌肉记忆，让你能够头脑清晰地去解决任何案例分析。
2. Step 1: Understanding the Problem | 第一步：理解问题
Before you draw a single flowchart symbol or write a line of pseudocode, you must truly understand what the problem is asking. Read the case study prompt at least twice. Underline or highlight the main goal, the constraints, and the expected inputs and outputs. In many CCEA tasks, the problem is presented as a short story — perhaps a teacher wants a program to calculate term grades or a shopkeeper needs a digital till.
在你画出任何一个流程图符号或写下一行伪代码之前，你必须真正理解问题在问什么。至少阅读案例描述两遍。用下划线或高亮标出主要目标、约束条件以及预期的输入和输出。在许多 CCEA 任务中，问题以短故事的形式呈现——可能是老师想要一个计算学期成绩的程序，也可能是店长需要一个电子收银机。
Let’s take a simple example: “A library needs a system to check whether a student can borrow a book. A student can borrow up to 3 books at a time. The system should take the student’s ID and the number of books they currently have on loan, and then output whether a new loan is allowed.” The goal is clear: determine eligibility. The input is student ID and current loan count; the output is a simple “Allowed” or “Not allowed”. Understanding this fully prevents you from going off track later.
我们来看一个简单的例子：“一个图书馆需要一套系统，用来检查学生是否能借书。一个学生一次最多可借3本书。系统应接收学生的ID和当前已借书籍数量，然后输出是否允许新借阅。”目标很明确：判断借阅资格。输入是学生ID和当前借书数量；输出是一个简单的“允许”或“不允许”。充分理解这一点可以防止你后续跑偏。
3. Step 2: Decomposition – Breaking It Down | 第二步：分解——化整为零
Decomposition means splitting a complex problem into smaller, more manageable sub‑problems. For the library example, you might break it down into: (1) obtaining the student ID, (2) checking the current number of books on loan, (3) comparing that number against the maximum allowance, and (4) displaying the result. Each of these can then be solved almost independently.
分解是指将一个复杂问题拆分成更小、更容易管理的子问题。对于图书馆例子，你可以将其分解为：(1) 获取学生ID，(2) 检查当前已借书籍数量，(3) 将该数量与最大限额进行比较，(4) 显示结果。这些子问题中的每一个几乎都可以独立解决。
When you decompose a case study, you naturally start to see the structure of your eventual algorithm. In Year 8, you are often asked to list the main steps before you design the solution. This list can be written in ordinary English, but it should be clear and in a logical order. Avoid mixing steps — for instance, do not try to output before you have compared. Decomposition keeps your thinking tidy and helps you spot missing steps early.
当你分解一个案例分析时，你很自然地就开始看到最终算法的结构。在八年级，你经常被要求在设计解决方案之前列出主要步骤。这个列表可以用普通的英语书写，但必须清晰并符合逻辑顺序。避免步骤混淆——例如，不要在完成比较之前就试图输出。分解让你的思维保持整洁，并帮助你及早发现遗漏的步骤。
4. Step 3: Abstraction – Focusing on What Matters | 第三步：抽象——聚焦要点
Abstraction is the skill of filtering out unnecessary detail so that you can concentrate on the parts that are important for the solution. In the library scenario, the colour of the student’s ID card or the title of the books they currently have are irrelevant — all that matters is the total number of loans. By abstracting, you create a model of the problem that contains only the essential data and rules.
抽象是一种筛选出无关细节、从而专注于对解决方案重要部分的技能。在图书馆场景中，学生ID卡的颜色或他们当前所借书籍的书名都是无关的——重要的只是借书的总数。通过抽象，你创建了一个仅包含本质数据和规则的问题模型。
Year 8 case studies often ask you to identify the variables you will use. This is a direct application of abstraction. For instance, you might define a variable currentLoans to store the loan count. The maximum allowed, 3, could be stored as a constant MAX_LOANS. The student’s name might be left out because the problem does not ask for it. Good abstraction makes your algorithm simpler and easier to translate into code later.
八年级的案例分析经常要求你确定将要使用的变量。这正是抽象的直接应用。例如，你可以定义一个变量 currentLoans 来存储借书数量。最大允许值3可以作为一个常量 MAX_LOANS 存储。学生的姓名可能会被省去，因为问题并没有要求。良好的抽象使你的算法更简单，之后也更易于转化为代码。
5. Step 4: Algorithm Design with Pseudocode | 第四步：用伪代码设计算法
Pseudocode is a way of writing algorithms in a structured, human‑readable format that resembles programming languages but avoids strict syntax. In CCEA Year 8, your pseudocode can use common verbs like OUTPUT, INPUT, IF…THEN…ELSE, and WHILE loops. The goal is to communicate your logic clearly, not to write perfect code. Here is the library case expressed in pseudocode:
伪代码是一种用结构化、人类可读的格式编写算法的方式，它类似于编程语言，但避免了严格的语法。在 CCEA 八年级，你的伪代码可以使用常见动词，如 OUTPUT、INPUT、IF…THEN…ELSE 和 WHILE 循环。目标是清晰传达你的逻辑，而不是写出完美的代码。下面是图书馆案例的伪代码表示：
OUTPUT “Enter student ID”
INPUT studentID
OUTPUT “Enter current number of books on loan”
INPUT currentLoans
IF currentLoans < 3 THEN
OUTPUT “Book loan allowed”
ELSE
OUTPUT “Too many books on loan – cannot borrow more”
ENDIF
输出 “输入学生 ID”
输入 studentID
输出 “输入当前借书数量”
输入 currentLoans
如果 currentLoans < 3 那么
输出 “允许借书”
否则
输出 “借书过多——无法再借”
结束条件判断
Notice how the pseudocode mirrors the decomposition. Every sub‑problem becomes a line or a block of logic. When writing pseudocode for case studies, you should also include comments to explain your thinking. For example, you could add # Check against maximum limit before the IF statement. This habit impresses examiners and demonstrates deep understanding.
注意伪代码是如何反映分解过程的。每个子问题都变成了一行或一个逻辑块。在为案例分析编写伪代码时，你还应加入注释来解释你的想法。例如，你可以在 IF 语句之前添加 # 检查是否超过最大限额。这个习惯会给考官留下深刻印象，并展示出深刻的理解。
6. Step 5: Visualising with Flowcharts | 第五步：用流程图进行可视化
Flowcharts use standard symbols to represent the flow of an algorithm. CCEA Year 8 expects you to know the common symbols: an oval for Start/End, a parallelogram for Input/Output, a rectangle for a process, and a diamond for a decision. Drawing a flowchart often reveals logical gaps that words alone miss. Let’s visualise the library algorithm with a simple description and symbol sequence:
流程图使用标准符号来表示算法的流程。CCEA 八年级要求你了解常用符号：椭圆形表示开始/结束，平行四边形表示输入/输出，矩形表示处理过程，菱形表示判断。绘制流程图常常能发现仅靠文字会遗漏的逻辑缺口。让我们用简单的描述和符号序列来可视化图书馆算法：
Start (oval) → “Enter student ID” (parallelogram) → INPUT studentID (parallelogram) → “Enter current loans” (parallelogram) → INPUT currentLoans (parallelogram) → Decision: currentLoans < 3? (diamond). If Yes → OUTPUT “Allowed” (parallelogram) → End. If No → OUTPUT “Not allowed” (parallelogram) → End.
开始（椭圆）→ “输入学生 ID”（平行四边形）→ 输入 studentID（平行四边形）→ “输入当前借书数量”（平行四边形）→ 输入 currentLoans（平行四边形）→ 判断：currentLoans < 3?（菱形）。如果是 → 输出 “允许”（平行四边形）→ 结束。如果否 → 输出 “不允许”（平行四边形）→ 结束。
When you describe a flowchart in a text‑based environment, always refer to the shape names. In an exam, you might be asked to draw one, but in a written analysis, this narrative method is perfectly acceptable. A well‑constructed flowchart can serve as a bridge between your case study analysis and the final algorithm, making your thought process transparent.
当你在纯文字环境下描述流程图时，始终要提及形状的名称。在考试中，你可能需要绘制流程图，但在书面分析中，这种叙述方法是完全可以接受的。精心构建的流程图可以充当案例分析与最终算法之间的桥梁，使你的思维过程透明化。
7. Step 6: Testing and Evaluation | 第六步：测试与评估
A case study is not complete until you have tested your solution. Testing involves running through your algorithm with sample data, including normal, boundary, and erroneous values. For the library system, normal data could be currentLoans = 1 (should be allowed). Boundary data: currentLoans = 2 (still allowed, just under the limit) and currentLoans = 3 (not allowed, exactly at limit). Erroneous data might be a negative number or a letter — how will your algorithm react? You should state how to handle such cases.
一个案例分析在你测试过你的解决方案之前是不完整的。测试包括用样本数据运行你的算法，这些数据包括正常值、边界值和错误值。对于图书馆系统，正常数据可以是 currentLoans = 1（应该允许）。边界数据：currentLoans = 2（仍然允许，刚好在限额之下）和 currentLoans = 3（不允许，刚好达到限额）。错误数据可能是负数或字母——你的算法会如何反应？你应说明如何处理这些情况。
Evaluation goes beyond testing; it asks whether the solution meets the original requirements, whether it is easy to use, and what could be improved. In Year 8, you can simply write a few sentences reflecting on your design. For example, “The algorithm assumes the user will input a number. A better version could include input validation to check that the value is a positive integer.” This shows higher‑order thinking.
评估超越了测试；它问的是解决方案是否满足最初的要求、是否容易使用，以及哪些方面可以改进。在八年级，你可以简单地写几句话反思你的设计。例如，“该算法假设用户会输入一个数字。更好的版本可以加入输入验证，检查该值是否为正整数。”这展现了高阶思维。
8. Case Study A: School Event Registration | 案例A：校园活动报名系统
Let’s apply these steps to a new scenario. Scenario: A school wants a program to manage sign‑ups for a school play. Each student can register for one role, but there are only 20 places available. The program should ask for the student’s name and the number of already registered places, and then either confirm the registration or display a “Full” message.
让我们将这些步骤应用到一个新场景中。场景：一所学校想要一个程序来管理校园剧的报名。每个学生可以报名一个角色，但只有20个名额。程序应询问学生姓名和已报名人数，然后要么确认报名成功，要么显示“名额已满”消息。
Let’s start with decomposition: (1) Display a welcome message. (2) Ask for the student’s name. (3) Ask for the current number of registrations. (4) Compare that number against 20. (5) If fewer than 20, increase the count by 1 and confirm; otherwise, show that it is full. (6) Display a final message. We also need a variable registeredCount and a constant MAX_PLACES = 20.
让我们从分解开始：(1) 显示欢迎消息。(2) 询问学生姓名。(3) 询问当前已报名人数。(4) 将该数字与20比较。(5) 如果少于20，将计数加1并确认；否则，显示名额已满。(6) 显示最终消息。我们还需要一个变量 registeredCount 和一个常量 MAX_PLACES = 20。
Abstraction: We ignore details like which role the student wants or their year group, because the problem focuses only on the capacity constraint. The only relevant data is the name and the running total.
抽象：我们忽略诸如学生想演哪个角色或他们的年级组等细节，因为问题只关注容量限制。唯一相关的数据是姓名和累计总数。
Here is the pseudocode:
OUTPUT “Welcome to School Play Registration”
OUTPUT “Enter student name”
INPUT studentName
OUTPUT “Enter current number of registered places”
INPUT registeredCount
IF registeredCount < 20 THEN
registeredCount = registeredCount + 1
OUTPUT “Registration successful for “, studentName, “. Total places taken: “, registeredCount
ELSE
OUTPUT “Sorry, the school play is already full.”
ENDIF
伪代码：
输出 “欢迎来到校园剧报名系统”
输出 “输入学生姓名”
输入 studentName
输出 “输入当前已报名人数”
输入 registeredCount
如果 registeredCount < 20 那么
registeredCount = registeredCount + 1
输出 “报名成功，”, studentName, “。已占名额：”, registeredCount
否则
输出 “抱歉，校园剧已满员。”
结束条件
For the flowchart, we would use: Start → “Enter name” (parallelogram) → INPUT name → “Enter registered count” → INPUT registeredCount → Decision: registeredCount < 20? → Yes: registeredCount = registeredCount + 1, then OUTPUT confirmation → End. No: OUTPUT “Full” → End.
流程图：开始 → “输入姓名”（平行四边形）→ 输入姓名 → “输入已报名人数” → 输入 registeredCount → 判断：registeredCount < 20? → 是：registeredCount = registeredCount + 1，然后输出确认 → 结束。否：输出 “已满” → 结束。
9. Case Study B: Number Guessing Game | 案例B：数字猜谜游戏
Scenario: Design a simple game where the computer picks a secret number between 1 and 10. The user gets three attempts to guess. After each wrong guess, the program should give a hint “Too high” or “Too low”. If the user guesses correctly within three tries, display a winning message; otherwise, reveal the number and end the game.
场景：设计一个简单游戏：计算机在1到10之间选取一个秘密数字。用户有三次猜测机会。每次猜错后，程序应给出“太高”或“太低”的提示。如果用户在三次内猜对，显示胜利消息；否则，揭晓数字并结束游戏。
Decomposition: (1) Set a secret number (e.g., secret = 7). (2) Set attempts counter to 0. (3) While attempts < 3: ask for a guess, increase attempts, check guess. (4) If guess equals secret, output win and exit loop. (5) If guess is higher or lower, give hint. (6) After loop, if all attempts used without correct guess, output lose message with secret.
分解：(1) 设定秘密数字（例如 secret = 7）。(2) 将尝试计数器设为0。(3) 当 attempts < 3 时：要求输入猜测，增加 attempts，检查猜测。(4) 如果猜测等于秘密数字，输出胜利并退出循环。(5) 如果猜测偏高或偏低，给出提示。(6) 循环结束后，如果所有尝试用完仍未猜对，输出失败消息并显示秘密数字。
Abstraction: The core variables are secret (constant in this simple version), guess, and attempts. The range 1-10 and the maximum attempts 3 are important constants. The user’s name or time taken are irrelevant for this basic design.
抽象：核心变量是 secret（在此简化版本中为常量）、guess 和 attempts。范围1-10和最大尝试次数3是重要的常量。用户的姓名或所用时间对于这个基本设计而言是无关的。
Pseudocode:
secret = 7
attempts = 0
WHILE attempts < 3 DO
OUTPUT “Guess a number between 1 and 10”
INPUT guess
attempts = attempts + 1
IF guess = secret THEN
OUTPUT “Congratulations! You guessed it in “, attempts, ” attempt(s).”
STOP loop
ELSE IF guess > secret THEN
OUTPUT “Too high. Try again.”
ELSE
OUTPUT “Too low. Try again.”
ENDIF
ENDWHILE
IF guess != secret THEN
OUTPUT “Out of attempts! The number was “, secret
ENDIF
伪代码：
secret = 7
attempts = 0
当 attempts < 3 执行
输出 “猜一个1到10之间的数字”
输入 guess
attempts = attempts + 1
如果 guess = secret 那么
输出 “恭喜！你用了 “, attempts, ” 次猜中了。”
停止循环
否则如果 guess > secret 那么
输出 “太高了。再试一次。”
否则
输出 “太低了。再试一次。”
结束条件
循环结束
如果 guess ≠ secret 那么
输出 “机会用完了！这个数字是 “, secret
结束条件
This case study introduces the WHILE loop and the concept of stopping early when the correct answer is found. A flowchart would feature a decision diamond inside a loop structure, with arrows looping back until the condition fails or the loop is exited.
这个案例分析引入了 WHILE 循环，以及当找到正确答案时提前退出的概念。流程图的特点是在循环结构中包含一个判断菱形，箭头会循环回去，直到条件不成立或循环被退出。
10. Case Study C: Temperature Converter | 案例C：温度转换器
Scenario: Create a program that converts a temperature from Celsius to Fahrenheit. The formula is: Fahrenheit = (Celsius × 9/5) + 32. The program should ask the user for a Celsius value and then display the equivalent Fahrenheit, rounded to one decimal place. However, if the Celsius value is below absolute zero (−273.15 °C), the program should warn the user that the input is physically impossible.
场景：创建一个将温度从摄氏度转换为华氏度的程序。公式为：华氏度 = (摄氏度 × 9/5) + 32。程序应要求用户输入一个摄氏度值，然后显示相应的华氏度，并保留一位小数。但是，如果摄氏度值低于绝对零度（−273.15 °C），程序应警告用户该输入在物理上是不可能的。
Decomposition: (1) Ask for Celsius temperature. (2) Check if it is below −273.15. (3) If yes, output error. (4) If no, compute fahrenheit = celsius × 9 ÷ 5 + 32. (5) Output the result. We will use the variables celsius and fahrenheit, and the constant ABSOLUTE_ZERO = −273.15.
分解：(1) 询问摄氏度温度。(2) 检查是否低于 −273.15。(3) 如果是，输出错误。(4) 如果否，计算 fahrenheit = celsius × 9 ÷ 5 + 32。(5) 输出结果。我们将使用变量 celsius 和 fahrenheit，以及常量 ABSOLUTE_ZERO = −273.15。
This example brings in data validation and the use of a constant with real‑world scientific meaning. The formula can be expressed using standard mathematical symbols. In pseudocode, we can write it clearly:
这个例子引入了数据验证和具有现实科学意义的常量的使用。公式可以用标准数学符号表达。在伪代码中，我们可以清晰地写出：
OUTPUT “Enter temperature in Celsius”
INPUT celsius
IF celsius < −273.15 THEN
OUTPUT “Error: Temperature below absolute zero is not possible.”
ELSE
fahrenheit = (celsius * 9 / 5) + 32
OUTPUT “Temperature in Fahrenheit: “, ROUND(fahrenheit, 1)
ENDIF
输出 “输入摄氏温度”
输入 celsius
如果 celsius < −273.15 那么
输出 “错误：低于绝对零度的温度是不可能的。”
否则
fahrenheit = (celsius * 9 / 5) + 32
输出 “华氏温度：”, ROUND(fahrenheit, 1)
结束条件
For the flowchart, the decision diamond checks “celsius < −273.15?”. The Yes path leads to an error output, while the No path goes through a process rectangle for the calculation before outputting the result. This visual clearly separates the exceptional path from the normal one, which is a hallmark of good algorithm design.
在流程图中，判断菱形检查“celsius < −273.15?”。是路径通向错误输出，否路径则经过一个表示计算的处理矩形，然后输出结果。这种可视化方式将异常路径与正常路径清晰分开，这是良好算法设计的一个标志。
11. Common Mistakes and How to Avoid Them | 常见错误及避免方法
When tackling case studies, Year 8 students often rush into writing an algorithm without fully decomposing the problem. The most frequent error is missing a step — for example, forgetting to increment a counter in a game loop, or not initialising a variable. Another pitfall is using variables without clear names; calling a variable x instead of currentLoans makes the logic harder to follow and to debug.
在解决案例分析时，八年级学生常常在没有完全分解问题的情况下就匆忙编写算法。最常见的错误是遗漏步骤——例如，忘记在游戏循环中递增计数器，或者没有初始化变量。另一个陷阱是使用含义不清的变量名；将变量命名为 x 而不是 currentLoans 会使逻辑更难理解和调试。
Flowchart errors also appear: using the wrong shape, forgetting to label arrows, or creating an infinite loop without a proper exit condition. In pseudocode, mistaking IF for WHILE and vice versa can completely change the program behaviour. Always test your pseudocode manually with a small data set to see if it behaves as expected. Asking a friend to read your algorithm aloud can help catch illogical sequences.
流程图错误也经常出现：使用错误的形状、忘记给箭头加标签，或者在没有合适退出条件的情况下创建无限循环。在伪代码中，混淆 IF 和 WHILE 会完全改变程序的行为。始终用一个小数据集手动测试你的伪代码，看它是否如预期那样运行。请一个朋友大声朗读你的算法，可以帮助发现不合理的顺序。
In testing, a common oversight is not considering boundary values. If a system allows up to 20 registrations, you must test with exactly 20
Published by TutorHao | Year 8 Computer Science Revision Series | aleveler.com
更多咨询请联系16621398022（同微信）
屏轩国际教育cambridge primary/secondary checkpoint, cat4, ukiset,ukcat,igcse,alevel,PAT,STEP,MAT, ibdp,ap,ssat,sat,sat2课程辅导，国外大学本科硕士研究生博士课程论文辅导