Computer Science 9618/22 — May/June 2024

Background Concept

In pseudocode, different statements belong to different programming constructs:

• Selection means a decision is made, usually with IF ... THEN ... ENDIF or CASE OF.
• Iteration means repetition, usually with FOR, WHILE, REPEAT or UNTIL as part of a loop.
• Input/Output means data is read in or written out, for example INPUT, OUTPUT, READFILE or WRITEFILE.

A single pseudocode example can belong to more than one category. For example, an IF containing a READFILE statement involves both selection and input/output.

Understanding the Question

You are given four short pieces of pseudocode and a table with three headings: selection, iteration and input/output. For each row, you must decide which categories apply.

The key clue is that the question says one or more ticks may be needed in each row. So you must not assume there is only one correct column per example.

Approach

Read each pseudocode example and look for the identifying keyword or operation:

• FOR or UNTIL suggests repetition.
• IF suggests selection.
• READFILE and WRITEFILE are file input/output operations.

Then tick every category that is present in that row.

Step-by-Step Reasoning

Row 1

FOR Index ← 1 TO 10 ... NEXT Index

• FOR and NEXT show a count-controlled loop.
• That means the statements inside are repeated.
• There is no decision being made, so it is not selection.
• There is no reading or writing to an external source, so it is not input/output.

So this row is iteration only.

Row 2

WRITEFILE ThisFile, "****"

• WRITEFILE sends data to a file.
• That is an output operation.
• There is no loop and no decision.

So this row is input/output only.

Row 3

UNTIL Level > 25

• UNTIL is the condition used with a repetition structure such as REPEAT ... UNTIL.
• It is part of an iterative construct.
• It is not by itself an input/output statement.
• It is also not treated as selection here; it controls when repetition stops.

So this row is iteration only.

Row 4

IF Mark > 74 THEN ... READFILE OldFile, Data ... ENDIF

• IF ... THEN ... ENDIF is selection, because a condition is tested.
• READFILE is input, so it is input/output.
• There is no repetition.

So this row needs two ticks: selection and input/output.

Key Takeaways

• IF indicates selection.
• FOR, WHILE, REPEAT, UNTIL indicate iteration.
• READFILE, WRITEFILE, INPUT, OUTPUT indicate input/output.
• One row can match more than one category.

Common Mistakes

• Ticking only one box per row when the question allows more than one.
• Treating READFILE as not I/O because it is not keyboard input. File access is still input/output.
• Missing that UNTIL belongs to repetition and leaving that row blank.
• Ticking selection for the UNTIL row. In this context it is part of a loop condition, so it is classified as iteration.

Things to Be Careful About

• Look at the whole row, not just one line. A row can contain both a control structure and an I/O statement.
• Distinguish between decision-making and loop control.
• In exam tables like this, ticks must be placed exactly in the relevant columns; avoid extra ticks.

Background Concept

A valid assignment means the value produced on the right-hand side must match the data type of the variable on the left-hand side.

Here the variables are:

• MyChar : CHAR
• MyString : STRING
• MyInt : INTEGER

Common pseudocode functions used for this include:

• INT(...) to convert a real number to an integer by taking the integer part.
• MID(String, Start, Length) to extract part of a string.
• RIGHT(String, Number) to take characters from the right-hand end.
• NUM_TO_STR(...) to convert a number to a string.
• STR_TO_NUM(...) to convert a numeric string into a number.

The main skill is to follow the types through the nested functions until the final result matches the target variable.

Understanding the Question

You are not being asked to evaluate the expressions. You are being asked to choose functions so that each assignment is type-correct.

That means:

• if the variable is INTEGER, the final result must be an integer;
• if the variable is STRING, the final result must be a string;
• if the variable is CHAR, the final result must be a single character.

Two of the expressions have nested blanks, so the inner function must produce something the outer function can use.

Approach

For each row:

1. Look at the variable on the left-hand side.
2. Decide what type the whole expression must end up as.
3. Choose a function, or nested functions, that transform the supplied data into that type.

This is really a type-matching exercise.

Step-by-Step Reasoning

1. MyInt ← .......................................... (3.1415926)

• MyInt must store an INTEGER.
• 3.1415926 is a real value.
• So we need a function that converts a real to an integer.
• INT(3.1415926) does this.

So the completed expression is:
MyInt ← INT(3.1415926)

2. MyChar ← .......................................... ("Elwood", 3, 1)

• MyChar must store a single character.
• The parameters (String, 3, 1) match the pattern of MID.
• MID("Elwood", 3, 1) extracts one character starting at position 3.
• In Elwood, the third character is w.
• A one-character result is suitable for MyChar.

So the completed expression is:
MyChar ← MID("Elwood", 3, 1)

3. MyString ← .......................................... ( .......................................... (27.509))

• MyString must end as a STRING.
• The inner function can turn 27.509 into an integer using INT.
• Then the outer function can convert that integer to a string using NUM_TO_STR.

So:

• inner: INT(27.509) gives 27
• outer: NUM_TO_STR(27) gives "27"

The completed expression is:
MyString ← NUM_TO_STR(INT(27.509))

4. MyInt ← .......................................... ( .......................................... ("ABC123", 3))

• MyInt must end as an INTEGER.
• The inner function needs to extract the numeric part of the string.
• RIGHT("ABC123", 3) gives "123".
• That is still a string, so the outer function must convert it to a number.
• STR_TO_NUM("123") gives the integer 123.

The completed expression is:
MyInt ← STR_TO_NUM(RIGHT("ABC123", 3))

Key Takeaways

• Always match the final expression type to the variable type.
• INT is useful for converting real values to integers.
• NUM_TO_STR and STR_TO_NUM are standard conversion functions.
• String functions such as MID and RIGHT are often used before type conversion.

Common Mistakes

• Using NUM_TO_STR when the target variable is an integer. That would produce the wrong type.
• Using STR_TO_NUM directly on "ABC123". The whole string is not purely numeric.
• Choosing LEFT("ABC123", 3) in the last row. That gives "ABC", which cannot be converted to an integer.
• Forgetting that nested blanks must both be filled so the final type works correctly.

Things to Be Careful About

• Keep the function names exactly as given in the insert.
• Check the parameter order for string functions such as MID.
• Make sure the inner function produces a valid input for the outer function.
• The question asks for a valid expression, so the important test is type correctness.

Background Concept

During the design stage of the program development life cycle, programmers document the parts of the program before coding. One useful document is an identifier table.

An identifier table records details about items such as variables, constants, arrays and sometimes files. This helps later when the program is corrected, updated or maintained, because another programmer can quickly see what each identifier is for.

Typical information in an identifier table includes:

• identifier name
• data type
• purpose/description
• scope
• initial value
• valid range or allowed values

Understanding the Question

The question tells you that the variables are chosen during the design stage and that the documentation should help with maintenance. So it is asking for:

1. a suitable way to document variables, and
2. one extra piece of information to record apart from the data type.

A standard answer is an identifier table, plus one useful extra field such as the variable's purpose.

Approach

Pick the most standard documentation method for variables used in Paper 2: an identifier table. Then choose one sensible extra item that helps someone understand the program later.

The best extra item is usually the purpose/description, because it explains what the variable stores or what it is used for.

Step-by-Step Reasoning

• The question is about documenting variables, not whole algorithms or testing.
• A suitable design document for variables is an identifier table.
• To make maintenance easier, the document should include more than just the type.
• Recording the purpose/description means a maintainer can see why the variable exists and how it should be used.

So a complete answer is:

• use an identifier table;
• record the purpose or description of each variable.

Key Takeaways

• An identifier table is used to document variables and other identifiers.
• Good documentation supports maintenance.
• Useful recorded details include purpose, scope, range and initial value, not just type.

Common Mistakes

• Giving a testing document instead of a variable-documentation method.
• Repeating data type as the extra piece of information, even though the question says to give something in addition to that.
• Naming a general document such as "design document" without giving a suitable specific method.

Things to Be Careful About

• The question asks for a way of documenting the variables, so be specific.
• Only one extra piece of information is needed; do not waste time listing many.
• Choose an item that genuinely helps maintenance, such as purpose, scope or valid range.

Background Concept

A flowchart shows an algorithm using standard symbols and arrows.

• A terminal/oval shows START or END.
• A parallelogram shows input or output.
• A rectangle shows a process such as an assignment or calculation.
• A diamond shows a decision, with branches such as Yes/No.

This question uses selection. Selection means the program chooses one path depending on a condition. Because the three input values are stated to be all different, there is exactly one largest value, so the logic can use simple > comparisons without needing to handle ties.

Understanding the Question

You are given a partially completed flowchart and asked to fill in the missing parts so it matches the algorithm described.

The algorithm must:

1. input Num1, Num2 and Num3
2. work out which is the largest and store it in Ans
3. calculate the average of the three numbers
4. output both the largest value and the average

The input box is already present. The missing parts are the two decision tests, the three assignment boxes for Ans, the rectangle for the average calculation, and the output box text.

Approach

To find the largest of three different numbers efficiently:

1. First test whether Num1 is greater than both other values.
2. If it is, Ans must be Num1.
3. Otherwise, compare Num2 and Num3.
4. If Num2 is greater than Num3, then Ans is Num2; otherwise Ans is Num3.
5. After the correct branch joins back together, calculate the average and output both results.

This matches the shape of the given flowchart: one decision, then another decision on the No branch, then three process boxes joining into one common path.

Step-by-Step Reasoning

The first decision must identify whether Num1 is definitely the largest. To do that, it must be greater than both Num2 and Num3, so the condition is:

Num1 > Num2 AND Num1 > Num3

• If this is Yes, the left process box must be Set Ans to Num1.
• If this is No, then Num1 is not the largest, so the largest must be either Num2 or Num3.

That is why the second decision is simply:

Is Num2 > Num3?

• If Yes, the middle process box is Set Ans to Num2.
• If No, the right process box is Set Ans to Num3.

After all three branches join, the next rectangle calculates the average:

Set Average to (Num1 + Num2 + Num3) / 3

Finally, the output box must display both required pieces of information, so it outputs a message containing Ans and Average.

A correct completed version is shown here:

Key Takeaways

• To find the largest of three different values, compare one value against both others first.
• Use AND when one value must satisfy two comparisons at the same time.
• In a flowchart, all branches that represent alternative choices should join before the next common step.
• A process box is used for assignments and calculations; a parallelogram is used for output.

Common Mistakes

• Using only Num1 > Num2 in the first decision. That is not enough, because Num3 might still be larger than Num1.
• Forgetting the AND Num1 > Num3 part of the first condition.
• Putting the average calculation inside only one branch instead of after all three branches rejoin.
• Outputting only the largest value or only the average when the question asks for both.
• Using Ans ← Num2 on the wrong branch of the second decision.

Things to Be Careful About

• The question says the values are all different, so strict > comparisons are fine.
• The average should use all three inputs: (Num1 + Num2 + Num3) / 3.
• The second decision is only reached if the first answer is No.
• Make sure each decision branch leads to the correct process box before merging back into the main flow.

Background Concept

When converting a flowchart into pseudocode, the main task is to recognise the three basic control structures:

• sequence: one step after another
• selection: a decision such as IF ... THEN
• iteration: repetition using WHILE, REPEAT ... UNTIL, or FOR

This flowchart also uses:

• a function call: GetStat() returns a value, which is stored in Flag
• a procedure call: Reset(Port) performs an action, so it is written with CALL

A useful skill is deciding which loop structure best matches the diagram. If the test happens after at least one pass through the loop, REPEAT ... UNTIL is often a good fit.

Understanding the Question

You are given a complete flowchart and asked to write equivalent pseudocode.

The flowchart does this:

1. set Flag to the result of GetStat()
2. if Flag is TRUE, stop
3. otherwise set Port to 1
4. while Port is not 4, call Reset(Port) and increase Port
5. when Port reaches 4, go back and check GetStat() again

So the algorithm keeps checking the status. If the status is not true yet, it resets ports 1, 2 and 3, then checks the status again.

Approach

The cleanest way to write this is:

• an outer REPEAT ... UNTIL loop for the repeated status checking
• inside that loop, an IF to decide whether port resetting is needed
• if resetting is needed, initialise Port to 1
• then use a WHILE loop to process ports until Port = 4

Why WHILE Port <> 4? Because the flowchart tests Is Port = 4? before performing Reset(Port). So Reset(4) must not happen. Only ports 1, 2 and 3 are reset.

Step-by-Step Reasoning

First declare the variables:

• Flag should be BOOLEAN because it is compared with TRUE
• Port should be INTEGER

The first action box is:

Set Flag to GetStat()

In pseudocode this becomes:

Flag ← GetStat()

Then the decision is Is Flag = TRUE?

• If Yes, the flowchart ends.
• If No, it continues to the port-reset section.

Because the diagram loops back to the GetStat() step after the port loop finishes, the whole process repeats until Flag becomes TRUE. That is why the outer structure can be written as:

REPEAT
   ...
UNTIL Flag = TRUE

Inside the loop, the reset section should only happen when Flag = FALSE, so we use:

IF Flag = FALSE THEN
   ...
ENDIF

Next, the flowchart sets Port to 1:

Port ← 1

Now consider the next decision: Is Port = 4?

• If No, do CALL Reset(Port) and then Set Port to Port + 1
• then go back to test Is Port = 4? again
• if Yes, leave the port loop and go back to the top of the outer loop

This means the repetition continues while Port is not 4:

WHILE Port <> 4
   CALL Reset(Port)
   Port ← Port + 1
ENDWHILE

Tracing it mentally:

• start with Port = 1 → not 4, so reset port 1, then port becomes 2
• Port = 2 → not 4, so reset port 2, then port becomes 3
• Port = 3 → not 4, so reset port 3, then port becomes 4
• Port = 4 → condition fails, so leave the loop and go back to check GetStat() again

So the full pseudocode is exactly:

DECLARE Flag : BOOLEAN
DECLARE Port : INTEGER

REPEAT
   Flag ← GetStat()
   IF Flag = FALSE THEN
      Port ← 1
      WHILE Port <> 4
         CALL Reset(Port)
         Port ← Port + 1
      ENDWHILE
   ENDIF
UNTIL Flag = TRUE

Key Takeaways

• Convert each flowchart symbol into the matching pseudocode structure.
• A returned value from a function is assigned to a variable.
• A procedure call is written with CALL.
• Choose the loop condition carefully so the correct values are processed; here ports 1 to 3 are reset, not port 4.

Common Mistakes

• Writing WHILE Port = 4 instead of WHILE Port <> 4. That reverses the logic.
• Starting Port at 0 or 4 instead of 1.
• Forgetting CALL before Reset(Port).
• Resetting port 4 even though the flowchart stops the inner loop when Port = 4.
• Using a FOR Port ← 1 TO 4 loop, which would usually include 4 and change the behaviour.

Things to Be Careful About

• Use the CIE assignment arrow ←, not =.
• GetStat() is used as a function because its value is assigned to Flag.
• Reset(Port) is used as a procedure because it performs an action.
• Flag must be tested correctly against TRUE/FALSE.
• The outer repetition continues until the status becomes true; the inner loop only handles the ports when the status is false.

Background Concept

A record is useful when one object has several different attributes. An array is useful when you need many objects of the same kind. An array of records combines both ideas:

• each record stores all the fields for one item
• the array stores many items of that same record type

This is a very common data structure because it matches real situations well. For example, a school may store many student records, or a factory may store many component records.

Understanding the Question

This part does not ask for code. It asks for three benefits of using an array of records for factory items.

So you need to think about why this structure is better than storing all values separately. The answer should focus on advantages such as organisation, access and processing.

Because the wording says "State three benefits", concise valid points are best. Long explanations are not needed in the exam answer.

Approach

Think of the two structures separately, then combine their advantages:

1. What does a record help with? It groups related fields for one item.
2. What does an array help with? It stores many similar items under one name and allows indexed access.
3. What does the combined structure help with? It makes processing many complete items easier using loops.

That gives you three clear benefit areas.

Step-by-Step Reasoning

First benefit: one item's data stays together.

A factory item has several fields: item number, reject status, stage, and two limits. If these were stored as unrelated separate variables, the data would be harder to manage. A record keeps them together as one complete unit. That improves organisation and reduces the chance of mixing up fields from different items.

Second benefit: many items can be stored in one structure.

A factory will have many items, not just one. An array allows the program to hold lots of Component records using one identifier, Item, with different index positions. This is better than having hundreds or thousands of separate variable names.

Third benefit: easy processing.

Because the items are in an array, the program can use loops to go through them one by one. That makes tasks such as searching, updating, counting rejected items, or printing reports much easier.

A further possible benefit, depending on marking tolerance, is direct indexed access. If you know the index, you can go straight to that position rather than scanning unrelated variables.

Key Takeaways

• Records organise all fields for one entity.
• Arrays organise many entities of the same type.
• Arrays of records are powerful because they support both structured storage and simple repeated processing.

Common Mistakes

• Giving a feature instead of a benefit, for example saying only "it uses an array". You need to say why that helps.
• Repeating the same idea in different words, such as "easy to access" and "simple to retrieve" without adding a distinct new benefit.
• Talking about benefits not linked to this structure, such as claiming it always uses less memory. That is not a guaranteed advantage.

Things to Be Careful About

• Make sure each point is separate enough to earn its own mark.
• Keep the answer focused on the combination of array and record, not just one of them.
• Avoid vague statements like "it is better" unless you explain better in what way.
• Since the question says three benefits, give at least three clear points.

Background Concept

The three common error types at this level are:

• syntax error: the code breaks language rules, so translation or compilation fails
• logic error: the program runs, but gives the wrong result
• run-time error: the program starts running, then fails or stops unexpectedly while executing

The key difference is when the problem appears.

Understanding the Question

The question says:

• all syntax errors have been corrected
• the program code compiles successfully
• when executed, it unexpectedly stops responding

So the problem is not during translation. It happens after the program has started to run.

Approach

Use elimination based on the stage of failure:

1. If it compiles, it is not a syntax error.
2. If it stops during execution, it is not simply a normal wrong-answer logic error.
3. Therefore it is a run-time error.

Step-by-Step Reasoning

A syntax error would have prevented the code from compiling. But the question explicitly says compilation succeeds.

A logic error usually means the program completes but produces an incorrect output. The description here is stronger: it “unexpectedly stops responding” during execution.

That behaviour matches a run-time error.

This is also consistent with the remaining issue in the pseudocode: attempting to use an invalid array index can cause a failure when the program runs.

Key Takeaways

• Always classify the error by when it happens.
• Compile failure points to syntax.
• Wrong result with successful execution points to logic.
• Failure during execution points to run-time.

Common Mistakes

• Writing “syntax error” even though the question says the program compiled.
• Writing “logic error” for any unexpected behaviour. A logic error usually still lets the program finish.
• Ignoring the phrase “when the program is executed”, which is the main clue.

Things to Be Careful About

• Read the timeline carefully: corrected syntax, compiled, then executed.
• In exam questions, words such as “compiles”, “runs”, “stops”, and “wrong output” are strong clues to the error type.
• Do not over-explain in a one-mark identification question; the correct label is enough.

Background Concept

This question is about string processing in pseudocode. A string can be examined using functions such as LENGTH, MID and LEFT.

• LENGTH(String) gives the number of characters.
• MID(String, Start, Count) extracts part of a string.
• LEFT(String, Count) takes the leftmost characters.

The algorithm also uses standard control structures:

• selection: decide whether trimming is needed
• iteration: keep removing words until the rule is satisfied
• sequence: carry out the steps in the correct order

The key idea is that the title must fit into 16 display positions, but if words are removed then ... must be added. Because the dots take 3 characters, the remaining title must be shorter than 14 characters before the dots are added. That is why the rule says less than 14, not less than or equal to 14.

Understanding the Question

We are asked to write a function Trim() that takes the original track title and returns the exact display string.

Important details from the question:

• If the title is 16 characters or fewer, it can be displayed unchanged.
• If it is longer than 16 characters, whole words are removed from the end.
• When a word is removed, the space before it is removed too.
• After one or more words have been removed, three dots are added to the end.
• The title must keep losing words until the remaining text is less than 14 characters.
• There is only one space between words, and the first word is guaranteed to be less than 14 characters.

So this is not character-by-character truncation. We must trim by whole words from the right-hand end.

Approach

A good strategy is:

1. Copy the original title into a working string.
2. Check if its length is already 16 or less.
   • If yes, return it unchanged.
3. Otherwise, repeatedly remove the last word.
   • To do that, start at the end of the string and move backwards until the space before the last word is found.
   • Keep only the characters to the left of that space.
4. Stop when the remaining title is less than 14 characters.
5. Add ... and return the result.

This matches the rules exactly and works for titles with any number of words.

Step-by-Step Reasoning

The function begins by declaring:

• DisplayTitle as the working copy of the title
• Position as the index used to search backwards

DisplayTitle ← OriginalTitle

This means we do not destroy the original parameter; we work on a copy.

Next:

IF LENGTH(DisplayTitle) > 16 THEN

Trimming only happens when the title is longer than the display width. If the length is 16 or less, the IF body is skipped and the original title is returned unchanged.

Inside the IF, we use a REPEAT ... UNTIL loop. A repetition structure is suitable because once we know the title is too long, we definitely need to remove at least one word.

Position ← LENGTH(DisplayTitle)

This starts the search at the final character of the current title.

WHILE MID(DisplayTitle, Position, 1) <> " "

This loop moves leftwards until a space is found. That space is the separator before the last word.

Position ← Position - 1

So if the string were Chris Sings the Blues, the pointer would move left from s in Blues, then through e, u, l, B, until it reaches the space before Blues.

When the space is found:

DisplayTitle ← LEFT(DisplayTitle, Position - 1)

This keeps everything before the space. That removes both:

• the last word
• the space in front of it

That is exactly what the question requires.

The loop ends when:

LENGTH(DisplayTitle) < 14

This condition is very important. If you stopped at 14 characters, then adding ... would produce 17 characters, which would not fit on a 16-character display.

Finally:

DisplayTitle ← DisplayTitle & "..."

The ellipsis is added only if trimming happened, because this line is inside the IF LENGTH(DisplayTitle) > 16 THEN block.

Then:

RETURN DisplayTitle

This returns either:

• the unchanged original title, or
• the trimmed title with dots added

For example, with Green Home Alabama:

• original length is more than 16, so trimming is needed
• remove Alabama
• remaining title becomes Green Home
• length is now less than 14
• add ...
• result is Green Home...

Key Takeaways

• Use string functions to manipulate text precisely.
• When trimming by words, search for the last space and cut there.
• Always match the stopping condition to the final size limit, including anything added afterwards.
• A function is appropriate because one input string produces one returned string.

Common Mistakes

• Trimming when the title has exactly 16 characters. The question says titles longer than 16 need trimming.
• Stopping when the remaining title is 14 characters. After adding 3 dots, the result would be too long.
• Removing only the last word but leaving the space before it. The question says the space must also be removed.
• Adding ... even when no words were removed. Dots are only added after trimming.
• Cutting characters from the end instead of removing whole words. The examples clearly show whole-word trimming.

Things to Be Careful About

• Use the exact built-in string operations consistently.
• Make sure the backward search starts at the last character of the current title, not the original title.
• The assumptions matter: single spaces between words and first word shorter than 14 characters make the loop safe.
• Keep the loop condition as less than 14, not less than or equal to 14.
• In CIE pseudocode, use the assignment arrow ←, not =.

Background Concept

Decomposition means breaking a larger problem into smaller sub-problems, often called modules or sub-modules. Each module should perform one clear task. This makes a solution easier to design, test, debug and maintain.

In program design, a good module usually:

• has a single purpose
• can be described clearly in one sentence
• fits into a larger sequence of processing
• can be tested on its own

For a real system, this often means separating input, processing and output tasks. For example, one module may detect a condition, another may collect the data needed, and another may produce the final result.

Understanding the Question

The new module is needed when a space becomes available in a class. At that point, the system must send a text message to each member on that class waiting list.

So the overall task is not one single action. The program must:

• know that a vacancy exists
• know which class it is for
• find the correct people on the waiting list
• send the message to them

The question asks for three sub-modules and what each one does. That means you are not writing code here; you are identifying sensible parts of the design.

Approach

A good way to answer is to think of the process in order:

1. detect that a place is free
2. get the waiting list data for the correct class
3. send the text messages

These are distinct tasks, so they make good sub-modules. Each one has a different responsibility, which is exactly what decomposition is meant to achieve.

Step-by-Step Reasoning

A suitable first sub-module is one that checks whether a class now has a free place. The waiting-list process should only happen if this condition is true, so this is a natural separate module.

A second useful sub-module is one that accesses the waiting list for that class. Once a vacancy is found, the system needs the list of members waiting for that specific class, along with enough details to contact them. The important piece of data here is the mobile phone number.

A third sub-module is one that sends the messages. This module would take the selected members and either compose a standard text message or use a prepared message, then send it to each person.

These three modules work together in sequence:

• vacancy found
• waiting list retrieved
• texts sent

That is a clear decomposed design.

Key Takeaways

• Decomposition breaks a larger problem into manageable modules.
• Each module should do one specific job.
• A strong answer names realistic modules and explains their purpose clearly.
• For system design questions, think in terms of input, processing and output steps.

Common Mistakes

• Giving only module names without saying what they do.
• Describing very vague modules such as "process data" or "do the task".
• Repeating the same idea three times in different words.
• Naming modules that are not really needed for the stated task.

Things to Be Careful About

• The question asks for three sub-modules, so give exactly three clear ones.
• Make sure each use is linked to this scenario: waiting lists, class spaces and text messages.
• A sub-module name should be specific enough to show its role.
• The description should explain the purpose of the module, not how to code it in detail.

Background Concept

A large processing task is often broken into smaller stages or modules. This is a form of decomposition. Instead of trying to do everything in one block, each stage has one clear job and passes its result to the next stage.

This improves software quality because:

• each stage is easier to understand
• each stage can be tested on its own
• faults are easier to locate
• later changes are easier to make

When each stage produces its own file, those files act like checkpoints. You can inspect the intermediate output and see whether the program is still working correctly before the next stage runs.

Understanding the Question

The teacher is processing student pseudocode files through several stages, for example source file, then stage 1 file, then stage 2 file.

The question asks for two linked ideas:

1. Why split the program into stages?
2. What is the benefit of producing a different file from each stage?

So one point should be about modular or staged design, and the other should be about how intermediate files help, especially with checking and debugging.

Approach

A strong answer should give:

• one sensible reason for using stages, such as easier testing, debugging, maintenance or clearer structure
• one specific benefit of separate output files, such as being able to inspect the result after each stage and identify where an error was introduced

The best answers do not just say "it is easier". They explain what becomes easier and why.

Step-by-Step Reasoning

The full task is to process a student's file through several transformations.

If the teacher wrote one huge program that did all transformations at once:

• it would be harder to understand
• an error could be anywhere in the whole process
• testing one part without running everything would be difficult

If the task is split into stages:

• stage 1 does one job
• stage 2 does another job
• each stage can be checked separately

Now consider the separate files:

• MichaelAday_src.txt is the original source file
• MichaelAday_S1.txt shows exactly what stage 1 produced
• MichaelAday_S2.txt shows exactly what stage 2 produced

If the stage 2 output is wrong, the teacher can inspect MichaelAday_S1.txt first.

• If S1 is already wrong, the fault is in stage 1.
• If S1 is correct but S2 is wrong, the fault is in stage 2.

That is why separate stage files are so useful for debugging and verification. They also preserve the original input file instead of overwriting it.

Key Takeaways

• Decomposition means splitting a problem into smaller parts or stages.
• Staged processing makes programs easier to test and debug.
• Intermediate files help you trace where an error first appears.
• Keeping outputs separate helps avoid losing the original data.

Common Mistakes

• Giving the same idea twice, for example saying "easier to debug" as both the reason and the benefit.
• Writing a vague answer such as "it is better" without explaining how or why.
• Talking about speed only. The question is much more about structure, testing and checking output.
• Describing separate files without linking them to debugging or checking intermediate results.

Things to Be Careful About

• The question asks for both a reason and a benefit, so give two distinct points.
• Make the benefit specifically about producing a different file from each stage, not just about modules in general.
• Keep the answer tied to the scenario of processing student files through multiple stages.

Background Concept

This is a string-processing function. A function is used when a module must return a value. Here, the input is a string called Line, and the output is another string with any leading spaces removed.

Leading spaces are spaces at the start of the string only. Spaces in the middle of the line must stay, because they are part of the pseudocode statement.

A common method is:

1. start at the first character
2. move forward while the character is a space
3. stop at the first non-space character
4. return the substring from that position to the end

Useful built-in string routines here are:

• LENGTH(Line) gives the number of characters
• MID(Line, Position, 1) gets one character from a chosen position
• MID(Line, Position, n) can return the rest of the string

Understanding the Question

The module DeleteSpaces() has already been specified for you:

• it receives one string parameter, Line
• it must return a string
• it removes only leading space characters

The example shows the intended effect clearly:

• before: " IF X2 > 13 THEN"
• after: "IF X2 > 13 THEN"

So the function must not remove spaces between words, and it must not just remove one space; it must remove all spaces at the front.

Approach

The safest approach is to keep track of a character position:

• set Position to 1
• while Position is still inside the string and the current character is a space, increase Position
• once the loop stops, Position is at the first non-space character, or just beyond the end if the string was all spaces
• return the substring from Position to the end

This approach is clear, matches CIE pseudocode style, and handles several cases correctly.

Step-by-Step Reasoning

Start with the function header:

• FUNCTION DeleteSpaces(Line : STRING) RETURNS STRING
• this tells us the module returns a string value

Then declare a variable:

• DECLARE Position : INTEGER
• we need this to move along the line character by character

Initialise it:

• Position ← 1
• strings in CIE pseudocode are normally treated using positions starting from 1

Now the loop:

• WHILE Position <= LENGTH(Line) AND MID(Line, Position, 1) = " "
• the first condition prevents reading past the end of the string
• the second condition checks whether the current character is a space

Inside the loop:

• Position ← Position + 1
• keep moving right until the first non-space is found

When the loop finishes, two things are possible:

1. Position points at the first non-space character
2. the whole string was spaces, so Position is one beyond the end

Finally:

• RETURN MID(Line, Position, LENGTH(Line) - Position + 1)
• this returns the substring from Position to the end

Example walkthrough:

Suppose Line is " IF X2 > 13 THEN".

• Position = 1, character is space, so move to 2
• Position = 2, character is space, so move to 3
• Position = 3, character is space, so move to 4
• Position = 4, character is I, so stop
• return from position 4 to the end
• result is "IF X2 > 13 THEN"

If there are no leading spaces:

• the loop does not run
• the whole original string is returned unchanged

If the line is empty or contains only spaces:

• the loop stops when Position goes past the length
• the returned substring has length 0, so the result is a blank string

Key Takeaways

• Use a function when you need to return a processed value.
• For leading-character removal, scan from the start until the condition stops being true.
• Guard string access with a length check to avoid going out of range.
• Only remove the part the question asks for: leading spaces, not all spaces.

Common Mistakes

• Removing every space in the string instead of only the leading ones.
• Forgetting to declare Position.
• Using = for assignment instead of ← in pseudocode.
• Not checking Position <= LENGTH(Line) before reading a character.
• Returning only one character or the wrong substring length.

Things to Be Careful About

• The question wants a function, not a procedure, because a string must be returned.
• Use exact CIE-style pseudocode keywords such as FUNCTION, WHILE, RETURN, and ENDFUNCTION.
• Make sure the loop stops at the first non-space character.
• Keep spaces inside the pseudocode statement untouched.

Background Concept

This question combines several Paper 2 ideas in one module:

• text file handling
• procedures and functions
• iteration using an end-of-file loop
• selection to decide whether to write a line

A procedure is used when a module performs actions but does not return a single value. Stage_2() performs file processing, so it is a procedure.

The usual pattern for sequential file processing is:

1. open the input file for reading
2. open the output file for writing
3. loop until EOF() is reached
4. read one line
5. process the line
6. write it if needed
7. close both files

The question also requires use of two existing functions:

• DeleteSpaces() removes leading spaces
• DeleteComment() removes any comment

By combining them, a line can become blank, and blank lines must not be written.

Understanding the Question

Stage_2() is given two parameters:

• the input file name
• the output file name

For every line in the input file, the procedure must:

1. remove leading spaces
2. remove comments
3. only write the line if it is not blank

At the end, it must output how many blank lines were removed.

A key instruction is: Modules DeleteComment() and DeleteSpaces() must be used in your solution. So the answer must explicitly call both of them.

Approach

The best structure is a standard file-processing loop.

Inside the loop:

• read one line into a string variable
• pass that string to DeleteSpaces()
• pass the result to DeleteComment()
• test whether the result is blank
• if not blank, write it to the output file
• otherwise increase a counter

A counter is needed because the final message must report how many blank lines were removed.

Step-by-Step Reasoning

Start with the procedure header:

• PROCEDURE Stage_2(InputFileName : STRING, OutputFileName : STRING)
• this matches the given module description exactly

Declare local variables:

• ThisLine : STRING stores the current line read from the file
• BlankLinesRemoved : INTEGER counts lines that become blank and are not written

Initialise the counter:

• BlankLinesRemoved ← 0

Open the files:

• input file for reading
• output file for writing

Then use an EOF loop:

• WHILE NOT EOF(InputFileName)
• this keeps processing until there are no more lines to read

Inside the loop:

1. READFILE InputFileName, ThisLine

   • get the next line from the input file

2. ThisLine ← DeleteSpaces(ThisLine)

   • remove any leading spaces first
   • this matters because a comment might begin after some spaces

3. ThisLine ← DeleteComment(ThisLine)

   • now remove any comment from the cleaned line

4. IF ThisLine <> "" THEN

   • check whether anything remains
   • if the line is not blank, it should be kept

5. WRITEFILE OutputFileName, ThisLine

   • write only non-blank processed lines

6. ELSE BlankLinesRemoved ← BlankLinesRemoved + 1

   • if the processed line is blank, do not write it
   • instead count it as a removed blank line

After the loop ends:

• close both files
• output the final count message

Why does this correctly count blank lines?

Because a line can be blank in more than one way:

• it was already empty
• it contained only spaces, and DeleteSpaces() turns it into ""
• it contained only a comment, perhaps after spaces, and after both functions it becomes ""

All of these should be excluded from the output file and included in the count.

Key Takeaways

• Use a procedure for a file-processing task that performs actions rather than returning one value.
• The standard file pattern is open, loop until EOF, read, process, write if needed, close.
• Reusing existing modules is good design and is often required by the question.
• A simple counter is enough when you must report how many items were skipped.

Common Mistakes

• Forgetting to call one of the required modules, especially DeleteSpaces().
• Writing blank lines to the output file instead of skipping them.
• Failing to initialise the counter to 0.
• Using a function header instead of a procedure header.
• Forgetting to close one or both files.
• Counting all input lines instead of only the blank lines removed.

Things to Be Careful About

• The order of processing matters: remove leading spaces before removing comments.
• The output file should receive only non-blank processed lines.
• Use ThisLine <> "" or an equivalent blank-line test correctly.
• Keep parameter names and pseudocode keywords consistent.
• Remember that this is Paper 2, so the answer must be in CIE pseudocode, not a real programming language.