Computer Science 9618/21 — October/November 2025

Background Concept

This question tests whether you can build valid pseudocode expressions by choosing functions and operators whose input types and output types match the variable being assigned to.

In pseudocode, the assignment must make sense by type:

• a STRING variable must be given a string value
• a CHAR variable must be given a single character
• an INTEGER variable must be given an integer value
• a DATE value can often be processed by date functions such as DAY, MONTH or YEAR

Common built-in functions and operators used here are:

• & for string concatenation
• MID(String, start, length) to extract part of a string
• DAY(Date) to extract the day number from a date
• NUM_TO_STR(Number) to convert a number into a string
• LENGTH(String) to count characters in a string
• INT(x) to take the integer part of a numeric value

The key skill is not just knowing the function names, but checking that each whole expression ends with the correct type.

Understanding the Question

You are given four incomplete assignment statements. For each one, you must fill the gaps using functions and/or operators from the insert so that the completed statement is valid.

That means each answer must satisfy two things:

1. the syntax must be correct
2. the data type on the right-hand side must match the variable on the left-hand side

For example, if the variable is MyInt, the completed expression must evaluate to an integer. If the variable is MyString, the expression must evaluate to a string.

Approach

A reliable way to tackle this kind of question is:

1. Look at the variable on the left of ←.
2. Decide what data type the right-hand side must produce.
3. Choose a function or operator from the insert that produces that type.
4. If there are nested functions, work from the inside outward.

That is especially important in the third and fourth expressions, where one function feeds into another.

Step-by-Step Reasoning

1. MyString ← 'X' .............................. MyString

MyString is a STRING, so the whole expression on the right must also be a string.

'X' is a character or one-character string, and MyString is already a string. The correct operation is concatenation, written as &.

So:

MyString ← 'X' & MyString

This puts X at the front of the existing string.

2. MyChar ← .............................. ("ABCD", ............... ,...............)

MyChar is a CHAR, so we need a function that extracts exactly one character from a string.

The function shape shown has three arguments, so MID is the natural match:

MID(String, start, length)

If we choose start position 2 and length 1, we extract just the character B.

So:

MyChar ← MID("ABCD", 2, 1)

Any valid one-character extraction using MID would satisfy the type requirement.

3. MyString ← .............................. (.............................. (MyDOB))

MyDOB is a DATE, but MyString must end up as a STRING.

So the inner function should turn the date into a numeric part, and the outer function should convert that number into a string.

A valid choice is:

• inner: DAY(MyDOB) gives the day number as an integer
• outer: NUM_TO_STR(...) converts that integer to a string

So:

MyString ← NUM_TO_STR(DAY(MyDOB))

This is valid because the final result is a string.

4. MyInt ← .............................. (.............................. (MyString) / 2)

MyInt is an INTEGER, so the whole expression must end as an integer.

The inner function should produce a number from MyString. LENGTH(MyString) does that by returning the number of characters.

Then it is divided by 2. Division may produce a non-integer result, so the outer function must turn it back into an integer. INT(...) does this.

So:

MyInt ← INT(LENGTH(MyString) / 2)

That is valid because INT ensures the assigned value is an integer.

Key Takeaways

• Always check the data type required on the left-hand side.
• Choose functions whose return values match that required type.
• For nested functions, work inside out.
• & joins strings, MID extracts part of a string, LENGTH returns a number, and conversion functions such as NUM_TO_STR change type.

Common Mistakes

• Using + instead of & for string concatenation. In CIE pseudocode, string joining is done with &.
• Choosing a function that returns the wrong type, such as assigning LENGTH(MyString) directly to a STRING variable.
• Forgetting the conversion function in NUM_TO_STR(DAY(MyDOB)), which would otherwise leave an integer being assigned to a string.
• Omitting INT(...) in the final expression, which could leave a non-integer result after division.
• Using MID with a length greater than 1 when assigning to a CHAR.

Things to Be Careful About

• Make sure the completed expression is valid, not just plausible.
• Use the exact pseudocode function names from the insert, such as NUM_TO_STR, LENGTH, MID and INT.
• Remember that / is real division, so if the final variable is an integer you often need INT(...).
• In substring functions, the argument order matters: string first, then start position, then length.
• A question like this may allow more than one valid expression, but every answer must still match the required type exactly.

Background Concept

Different testing methods are used at different points in program development.

Some important ones are:

• Unit testing: testing a single module as soon as it has been coded
• Integration testing: testing modules together as they are combined
• Black-box testing: testing using inputs and outputs without looking at the program code
• White-box testing: testing with knowledge of the internal code and paths
• Alpha testing: testing carried out by the developers, often in-house
• Beta testing: testing carried out by end users or the customer in a real or realistic environment

The important exam skill is to recognise the clue phrases in the description.

Understanding the Question

You are given short descriptions of testing situations and must identify the matching test method.

The three blanks describe:

• testing while modules are being joined together
• testing by developers without looking at the code
• testing by the customer

Each description points quite directly to a named testing method.

Approach

Look for the defining phrase in each row:

• modules being combined points to integration
• without referring to the code points to black-box
• completed by the customer points to beta

This is mostly a terminology-matching task.

Step-by-Step Reasoning

1. Carried out as program modules are being combined

When separately coded modules are joined together, the test being performed is integration testing.

This checks whether modules work correctly with each other, not just on their own.

2. Completed by the developers without referring to the code

If the testers do not look at the internal code and judge the program only by inputs and outputs, this is black-box testing.

The phrase "without referring to the code" is the key clue.

3. Completed by the customer

Testing done by the customer or end users is beta testing.

This usually happens after earlier internal testing stages and helps confirm that the software meets real user needs.

Key Takeaways

• Integration testing is for combined modules.
• Black-box testing ignores the internal code and focuses on behaviour.
• Beta testing is done by customers or end users.
• Learn the trigger words that identify each test method quickly.

Common Mistakes

• Confusing unit testing with integration testing. Unit testing is one module; integration testing is modules working together.
• Confusing alpha and beta testing. Alpha is done internally by developers; beta is done by customers or external users.
• Confusing black-box and white-box testing. Black-box means no reference to internal code.

Things to Be Careful About

• Read the wording closely: "as modules are being combined" is specifically about integration.
• "Without referring to the code" is about the method of testing, not the stage.
• "Completed by the customer" refers to who performs the test, which is the clue for beta testing.
• In exam tables, only write the testing method asked for; do not add long explanations unless requested.

Background Concept

An IDE provides tools to help a programmer find and fix errors. When an error has already been noticed, the next task is to locate where it happens.

The report window is useful because it shows current values stored in variables. However, seeing values alone is not always enough. You also need ways to control the execution of the program so that you can inspect those values at the right moment.

Two common IDE debugging features are:

• Breakpoints: markers placed on particular lines so the program pauses when it reaches them
• Single stepping or trace: executing the program one statement at a time

These features are especially useful for finding logic errors, where the program runs but produces wrong results.

Understanding the Question

The question already tells you that the report window is being used to examine variable values. You are not being asked to explain the report window itself.

Instead, you must explain two other IDE features and how they work together with the report window to help find the error.

So a strong answer needs:

1. name a suitable IDE feature
2. explain what it does
3. link it to checking values in the report window
4. show how this helps narrow down the location of the error

Approach

Choose two debugging tools that naturally combine with variable inspection.

The best choices are usually:

• breakpoints, because they stop the program at a chosen place so you can inspect values there
• single stepping/trace, because they let you observe values changing line by line

These two features complement the report window very well, so they make a clear, exam-style answer.

Step-by-Step Reasoning

1. Breakpoints

A breakpoint is set on a line where the programmer suspects the problem may occur.

When the program runs and reaches that line, execution pauses. At that moment, the programmer looks at the report window to inspect the current variable values.

This helps in two ways:

• it shows whether the values are already wrong before that line
• it shows whether the values become wrong after that line is executed

So breakpoints help you stop at a meaningful point, and the report window shows the data state at that point.

2. Single stepping / trace

Single stepping means executing the program one line at a time.

After each step, the programmer checks the report window to see how the variables have changed.

This is useful because it lets you identify the exact statement where a value first becomes incorrect. Instead of just knowing that the final output is wrong, you can see the moment the data goes wrong.

That makes it much easier to find the faulty line or faulty condition in the code.

These two features are often used together:

• use a breakpoint to jump straight to the suspicious region
• then single-step through that section while watching variable values in the report window

Key Takeaways

• The report window shows what values variables currently hold.
• A breakpoint helps you stop the program at a chosen place.
• Single stepping helps you follow execution line by line.
• Together, these tools help locate logic errors by showing exactly where values become incorrect.

Common Mistakes

• Describing the report window only, when the question asks for two other IDE features.
• Naming features without explaining how they work with variable values.
• Giving general IDE features such as syntax highlighting or auto-completion, which do not directly help locate a runtime logic error in this context.
• Forgetting to link the feature to finding the error, not just running the program.

Things to Be Careful About

• The question says two features, so make sure you provide two distinct ones.
• Explain the interaction with the report window, not just the feature in isolation.
• Focus on debugging features that help while the program is executing.
• Use precise terminology such as breakpoint, single stepping, or trace, because these are standard IDE debugging terms.

Background Concept

A record and an array solve different storage problems.

• A record groups different fields that belong to one item.
• An array stores many items of the same type.

When combined, an array of records is a very common design:

• one record = one real-world entity
• the array = the whole collection of those entities

Here, one rental has several fields, so a record is appropriate. The business has many rentals, so an array of those records is appropriate.

Understanding the Question

This part is not asking for code. It asks for three benefits of using an array of records to store all rentals.

So the answer should explain why this design is useful, rather than showing syntax.

The important idea is to think about both parts of the structure:

• what advantage records give
• what advantage arrays give

Approach

A good way to answer is to identify three practical benefits from the viewpoint of program design:

1. data for one rental stays together
2. many rentals can be stored consistently
3. the collection becomes easy to process with loops and indexes

These are strong general benefits and fit the car-rental scenario well.

Step-by-Step Reasoning

First benefit: records keep related data together.

A rental is not just one value. It has an ID, a car number, a discount code, a date, a duration and a completion flag. If these were stored as separate unrelated variables, it would be harder to keep them connected. A record solves that by bundling them into one structure.

Second benefit: arrays allow many rentals to be stored efficiently.

Instead of declaring hundreds of separate variables such as Rental1, Rental2, Rental3, and so on, one array name can hold the whole set. This makes the program shorter, clearer and easier to manage.

Third benefit: array indexing makes processing easier.

Because the records are stored in numbered positions, the program can use loops to move through them. That makes common tasks easier, such as:

• searching for a rental
• updating a rental
• printing all rentals
• checking which rentals are completed

That is why "easy processing by index" is a strong exam point.

Key Takeaways

• Records are used for one complex item with multiple fields.
• Arrays are used for many items of the same type.
• An array of records is ideal when you need many similar real-world objects, each with several attributes.
• This design improves organisation, readability and processing.

Common Mistakes

• Giving features instead of benefits, for example just saying "it uses an array" without explaining why that helps.
• Repeating the same idea three times in slightly different words.
• Talking only about records and ignoring the benefit of the array, or vice versa.
• Giving vague points such as "it is better" without saying how it is better.

Things to Be Careful About

• The question asks for three benefits, so give three distinct points.
• Make each point specific to storage or processing of rentals.
• Benefits such as easier searching, updating and looping are stronger than very general statements.
• Avoid discussing implementation details that were not asked for, such as memory addresses or file storage.

Background Concept

A 1D array stores multiple values of the same data type in indexed positions. Here, Number is a global array of 20 REAL values, so the procedure must place values into successive positions without going past the end of the array.

This task also uses the three main programming constructs:

• sequence: statements carried out in order
• selection: deciding what to do using IF ... THEN ... ELSE
• iteration: repeating a block using a loop

A common pattern for this kind of question is:

1. deal with the first item separately
2. keep a count of how many values have been stored
3. compare each new item with the previous one
4. stop when the required condition is no longer true or when the array is full

Because the array has a fixed size, the loop must include a bounds check such as Count < 20 before storing another value.

Understanding the Question

The procedure Store() must read real numbers one at a time and store them in the global array Number.

The rules are:

• the first value always goes into the first array element
• each later value is only stored if it is larger than the value entered immediately before it
• as soon as a value is not larger than the previous value, input stops
• input must also stop if the array becomes full
• finally, the procedure must output how many values were stored, with a message

So this is not just "store up to 20 values". It is "store an increasing sequence until it stops increasing, or until 20 values have been stored".

Approach

The cleanest approach is:

1. declare variables for the previous value, current value, count, and a Boolean flag
2. input the first value before the loop and store it in Number[1]
3. set Count to 1 because one value has already been stored
4. repeat while there is still space in the array and the sequence has not ended
5. input the next value
6. if it is larger than the previous value, store it in the next array element and update the previous value
7. otherwise, set a flag so the loop stops
8. after the loop, output the count and a message

The important design choice is handling the first value outside the loop. That avoids awkward special cases inside the loop, because after the first input there is always a valid "previous value" available for comparison.

Step-by-Step Reasoning

Start with the declarations:

• PreviousValue and CurrentValue must be REAL because the sequence contains real values.
• Count must be INTEGER because it counts how many values have been stored.
• Finished must be BOOLEAN because it represents whether the procedure should stop.

Then input the first value:

• INPUT PreviousValue
• this first value is stored immediately in Number[1]
• Count ← 1 because one value is now in the array
• Finished ← FALSE because processing has not ended yet

Now consider the loop condition:

• Count < 20 means there is still room for another value
• Finished = FALSE means the increasing-sequence rule has not been broken yet
• both conditions must be true for the loop to continue

Inside the loop:

1. input the next value into CurrentValue
2. compare it with PreviousValue
3. if CurrentValue > PreviousValue, then:
   • increase the count
   • store the value in the next free array element
   • update PreviousValue so the next comparison uses the newly accepted value
4. otherwise:
   • do not store the value
   • set Finished ← TRUE so the loop ends

Why update PreviousValue only after storing?
Because the next comparison must be against the last valid stored value, not against a rejected one.

Finally, after the loop ends, output the count with a suitable message. The loop can end in two ways:

• the next input is not larger than the previous one
• Count reaches 20, so the array is full

In both cases, the number of values actually stored is held in Count, so one final OUTPUT statement is enough.

Key Takeaways

• When processing a sequence based on comparison with the previous item, it is often easiest to read the first value before the loop.
• Fixed-size arrays must always be protected by a bounds check.
• A Boolean flag is a clear way to stop a loop when a condition fails.
• Keep separate variables for the "current" and "previous" values when comparing sequential input.

Common Mistakes

• Not storing the first value separately: this leaves nothing valid to compare the second value against.
• Forgetting to update PreviousValue after accepting a new value: then later comparisons use the wrong reference value.
• Using <= 20 in the loop condition: that risks trying to store beyond the last array element.
• Incrementing Count in the wrong place: if done too early or too late, the value may be stored in the wrong position.
• Stopping only when the sequence fails and not when the array is full: this breaks the array bound requirement.
• Using = instead of ← for assignment in pseudocode: CIE expects the assignment arrow.

Things to Be Careful About

• The array has 20 elements, so if Count = 20, no further value can be stored.
• The comparison must be with the previous value input that was accepted, not simply any earlier value.
• The question says all variables must be declared, so every local variable used in the procedure must appear in DECLARE statements.
• The final output must give the count together with a message, not just the number alone.
• Keep to CIE pseudocode style: upper-case keywords, correct assignment arrow, and matching ENDIF, ENDWHILE, and ENDPROCEDURE.

Background Concept

A check digit is an extra digit added to data so that the data can be tested later for errors. In this question, the rule is very simple:

1. Add all digits of the original number.
2. Find the remainder when that total is divided by 10.
3. Use that remainder as the check digit.
4. Put the check digit at the end.

For 4162:

• sum of digits = 4 + 1 + 6 + 2 = 13
• remainder when divided by 10 = 3
• new number = 41623

This kind of method can detect some errors, especially many single-digit errors, but it is not perfect. If different digits still produce the same overall sum remainder, the wrong number can pass the check.

Understanding the Question

You are told that 41623 was entered incorrectly, but:

• the last three digits were entered correctly, so the entry must end in 623
• the first two digits were wrong
• when the number was tested, it was still accepted

So you need to find a different five-digit number of the form:

• _ _ 623

such that the first four digits still produce check digit 3.

The important clue is that this check-digit system depends only on the sum of the first four digits, not on the position of the digits.

Approach

Start with the known correct number 41623.

The original four-digit part is 4162, whose digit sum is 13.

To be accepted, the incorrect first four digits must also have a digit sum that gives remainder 3 when divided by 10. Since the last two original digits 6 and 2 are fixed, their contribution is already 8.

So the new first two digits must add up to a value that makes the whole total end in 3. A total of 13 is the easiest match, so the first two digits should add to 5.

Any pair of wrong digits adding to 5 will work, provided they are not 4 and 1.

Step-by-Step Reasoning

The correct number is:

• original part: 4162
• check digit: 3

Check:

• 4 + 1 + 6 + 2 = 13
• 13 divided by 10 leaves remainder 3

Now we need a different entry with:

• first two digits wrong
• last three digits still 623

Choose 23623.

Now test it using the same rule:

• original part entered = 2362
• sum of digits = 2 + 3 + 6 + 2 = 13
• 13 divided by 10 still leaves remainder 3
• check digit entered = 3

So the calculated check digit matches the entered last digit.

That means the system accepts the number, even though the first two digits are wrong.

Why? Because this method only uses the digit sum remainder. It does not know which positions changed; it only sees that the total still gives the same remainder.

Key Takeaways

• A check digit is used to detect some input errors.
• This method depends on the sum of the digits modulo 10.
• Different numbers can produce the same check digit.
• Therefore, this method can miss some multiple-digit errors.

Common Mistakes

• Giving a number where one of the last three digits changes. The question says the last three digits were entered correctly, so they must remain 623.
• Giving a number where one of the first two digits is still correct. The question says the first two digits were entered incorrectly, so both must change.
• Choosing digits that do not preserve check digit 3. The new first four digits must still give a remainder of 3.
• Explaining only that the number is "wrong" without showing why it still passes the test. The explanation must link to the digit sum and remainder.

Things to Be Careful About

• The check digit is calculated from the original number only, not including the check digit itself.
• The last digit of the entered number is compared with the calculated check digit.
• This method is based on remainder after division by 10, so totals such as 13, 23, 33 and so on all give check digit 3.
• There are many valid answers, not just one. Any number of the form _ _ 623 with both first digits wrong and the same resulting remainder would be acceptable.

Background Concept

This question is about writing a function in CIE pseudocode.

A function is used when a module must return a value. Here, Generate() receives the original number and must return the new number with the check digit added, so a function is the correct choice.

There are three key programming ideas involved:

1. Iteration

   • We need to process every digit in the number.
   • A loop is used until there are no digits left.

2. Digit extraction from an integer

   • MOD 10 gives the last digit.
   • DIV 10 removes the last digit.

   Example with 4162:

   • 4162 MOD 10 = 2
   • 4162 DIV 10 = 416
   • then 416 MOD 10 = 6
   • then 416 DIV 10 = 41, and so on

3. Appending a digit to the end of a number

   • Multiply the original number by 10 to shift all digits left by one place.
   • Add the check digit.

   Example:

   • 4162 * 10 = 41620
   • 41620 + 3 = 41623

The question also states that the remainder must be found using integer division. A standard way to do that is:

So if the sum is 13:

• 13 DIV 10 = 1
• 1 * 10 = 10
• 13 - 10 = 3

Understanding the Question

You must write pseudocode for a module called Generate().

What it receives:

• one integer parameter, representing the original number

What it must return:

• the original number with its check digit appended

What the algorithm must do:

• find the sum of all digits in the original number
• calculate the remainder when that sum is divided by 10
• use that remainder as the check digit
• append it to the end of the original number
• return the new integer

The phrase "Assume that the parameter is valid" means you do not need extra validation code for length, type, or negative values.

Approach

The cleanest method is to keep two versions of the number:

• OriginalNumber stays unchanged so it can be used later when appending the check digit
• TempNumber is copied from it and then reduced digit by digit inside the loop

The algorithm structure is:

1. Set SumDigits to 0.
2. Copy the parameter into TempNumber.
3. While TempNumber > 0:
   • take the last digit with MOD 10
   • add it to the total
   • remove that digit with DIV 10
4. Calculate the check digit from the sum.
5. Append the check digit to the original number.
6. Return the new number.

This is efficient and uses arithmetic only, so there is no need to convert the number to a string.

Step-by-Step Reasoning

Here is what each part of the solution does.

FUNCTION Generate(BYVAL OriginalNumber : INTEGER) RETURNS INTEGER

• The module must return a value, so FUNCTION is appropriate.
• OriginalNumber is passed in.
• The function returns an INTEGER.

   DECLARE TempNumber, Digit, SumDigits, CheckDigit, NewNumber : INTEGER

• TempNumber is used to work through the digits without losing the original input.
• Digit stores the current last digit.
• SumDigits is the running total of all digits.
• CheckDigit stores the remainder.
• NewNumber stores the final answer to return.

   SumDigits ← 0
   TempNumber ← OriginalNumber

• The accumulator must start at 0.
• The original number is copied so it is preserved.

   WHILE TempNumber > 0
      Digit ← TempNumber MOD 10
      SumDigits ← SumDigits + Digit
      TempNumber ← TempNumber DIV 10
   ENDWHILE

This loop processes one digit each time.

Suppose OriginalNumber = 4162.

First iteration:

• TempNumber = 4162
• Digit = 4162 MOD 10 = 2
• SumDigits = 0 + 2 = 2
• TempNumber = 4162 DIV 10 = 416

Second iteration:

• Digit = 416 MOD 10 = 6
• SumDigits = 2 + 6 = 8
• TempNumber = 416 DIV 10 = 41

Third iteration:

• Digit = 41 MOD 10 = 1
• SumDigits = 8 + 1 = 9
• TempNumber = 41 DIV 10 = 4

Fourth iteration:

• Digit = 4 MOD 10 = 4
• SumDigits = 9 + 4 = 13
• TempNumber = 4 DIV 10 = 0

Now TempNumber > 0 is false, so the loop ends.

   CheckDigit ← SumDigits - ((SumDigits DIV 10) * 10)

• This calculates the remainder after division by 10 using integer division.
• With SumDigits = 13:
  • 13 DIV 10 = 1
  • 1 * 10 = 10
  • 13 - 10 = 3
• So CheckDigit = 3

   NewNumber ← (OriginalNumber * 10) + CheckDigit

• Multiplying by 10 shifts the digits left by one place.
• Then the check digit is added on the end.
• For 4162:
  • 4162 * 10 = 41620
  • 41620 + 3 = 41623

   RETURN NewNumber
ENDFUNCTION

• The completed new number is returned to the caller.

A valid alternative would be to use:

CheckDigit ← SumDigits MOD 10

but because the question specifically describes calculating the remainder using integer division, the subtraction method matches the wording more closely.

Key Takeaways

• Use a function when a module must return a value.
• MOD 10 gets the last digit of an integer.
• DIV 10 removes the last digit.
• A loop can process every digit of a number without converting it to text.
• To append one digit to a number, multiply the number by 10 and add the digit.
• A remainder can be found from integer division by subtracting the largest lower multiple of the divisor.

Common Mistakes

• Changing OriginalNumber directly in the loop. If you do this, you lose the original value needed for appending the check digit.
• Forgetting to initialise SumDigits to 0. The total would then be undefined.
• Using TempNumber ← TempNumber / 10 instead of DIV 10. Ordinary division may produce a real number, which breaks digit processing.
• Returning only the check digit instead of the new full number.
• Appending incorrectly, for example using OriginalNumber + CheckDigit instead of (OriginalNumber * 10) + CheckDigit.
• Writing a procedure instead of a function. The question says the module will return a value.

Things to Be Careful About

• In CIE pseudocode, assignment must use ←, not =.
• MOD and DIV are integer operations and are essential here.
• The loop condition should be TempNumber > 0 so that all digits are processed and the loop stops once the number has been reduced to 0.
• Declare all local variables with their types.
• Keep the parameter and identifier names consistent. If the question gives Generate(), use that exact module name.
• The question says the original number is at least three digits, but the algorithm works for any positive integer with one or more digits because the loop continues until no digits remain.

Background Concept

A state-transition diagram shows how a system moves between states. Each arrow represents a transition caused by an input. The label on the arrow normally shows the input and, if there is one, the output produced during that transition.

The main ideas are:

• A state is the current condition of the system, such as S1, S2 or S4.
• The current state tells you where the arrow starts.
• The next state tells you where the arrow ends.
• The input is the event that causes the change.
• The output is what the system produces during that change.
• If the current state and next state are the same, the transition is drawn as a self-loop.
• If no output is given, the transition label contains only the input.

This is a common way to document algorithms or systems whose behaviour depends on what state they are currently in.

Understanding the Question

You are given a transition table with four columns:

• current state
• input
• output
• next state

You must use that table to complete the unfinished state-transition diagram. The start state is already shown as S1, and one transition A2 | X2 is already drawn from S1 to the upper state. The remaining empty circles and unlabeled arrows must be identified and completed so that the diagram matches every row in the table.

So this is not a pseudocode task. It is a diagram-reading and diagram-completion task.

Approach

The best method is to process the table one row at a time.

For each row:

1. Find the current state.
2. Start an arrow from that state.
3. Find the next state.
4. End the arrow at that state.
5. Write the label as input | output if an output exists.
6. If the output cell is blank, write only the input.
7. If current state and next state are the same, draw a self-loop.

Also use the partly completed diagram to identify which blank circle must be S2, S3, S4 and S5.

Step-by-Step Reasoning

Start with what is already provided:

• START points to S1.
• S1 with input A2 and output X2 goes to the upper state, so that upper state must be S3.

Now use the rest of the table.

1. S1, input A1, output X1, next state S2

   • Draw an arrow from S1 to S2.
   • Label it A1 | X1.
   • This identifies the lower-left blank state as S2.

2. S2, input A4, output X4, next state S5

   • Draw an arrow from S2 to S5.
   • Label it A4 | X4.
   • This identifies the bottom state as S5.

3. S3, input A1, no output, next state S3

   • Current and next state are the same, so this is a self-loop on S3.
   • The label is just A1.

4. S3, input A3, output X3, next state S2

   • Draw an arrow from S3 to S2.
   • Label it A3 | X3.

5. S3, input A2, output X4, next state S4

   • Draw an arrow from S3 to the right-hand blank state.
   • Label it A2 | X4.
   • This identifies that state as S4.

6. S4, input A1, output X1, next state S4

   • Draw a self-loop on S4.
   • Label it A1 | X1.

7. S4, input A3, no output, next state S2

   • Draw an arrow from S4 to S2.
   • Label it A3 only.

8. S4, input A4, output X4, next state S5

   • Draw an arrow from S4 to S5.
   • Label it A4 | X4.

That completes all rows in the table, so the completed diagram is:

Key Takeaways

• A transition table can be converted directly into a state-transition diagram.
• Current state is where the arrow starts, and Next state is where it finishes.
• A self-loop is used when the system stays in the same state.
• If the output cell is blank, the transition label should contain only the input.

Common Mistakes

• Reversing the direction of a transition by using next state as the start and current state as the end.
• Writing A1 | or A3 | when no output exists. If there is no output, only the input should appear.
• Missing self-loops on S3 or S4.
• Putting A3 | X3 on the wrong transition. It must go from S3 to S2.
• Confusing which blank state is S2, S4 or S5.

Things to Be Careful About

• Use every row in the table exactly once.
• Keep the state names exact: S1, S2, S3, S4, S5.
• Keep the labels exact: A1 | X1, A2 | X2, A2 | X4, A3 | X3, A4 | X4, A1, A3.
• Do not invent extra transitions that are not in the table.
• Make sure the two blank-output transitions are written without an output part.

Background Concept

A structure chart documents the modular design of a program. It shows which module calls which other modules and what information passes between them.

Important conventions are:

• A module is shown as a box.
• A line from one module to another shows that the higher module calls the lower one.
• A procedure performs an action but does not return a value.
• A function returns a value to the module that called it.
• A data couple shows data being passed between modules.
• A control couple shows a control flag or logical result affecting what happens next.
• BYREF means the called module can change the original variable, so the data effectively goes down and comes back changed.
• An iteration symbol above a set of calls shows those modules are called repeatedly.

In a structure chart, the direction of the arrow matters:

• parameters usually go down from caller to called module
• return values go up from function to caller

Understanding the Question

You are given six module headers:

• PROCEDURE Setup()
• PROCEDURE Restart(H1 : STRING, C1 : INTEGER)
• FUNCTION Modify(B1 : BOOLEAN) RETURNS INTEGER
• PROCEDURE Final(T1 : INTEGER)
• PROCEDURE Update(BYREF R2 : STRING)
• FUNCTION Confirm() RETURNS BOOLEAN

You are also told that Setup repeatedly calls three modules.

The partial structure chart already gives useful clues:

• Setup is the top module.
• There are three child boxes under Setup.
• The left child has an incoming downward data couple labelled H1, so that module must be Restart(H1 : STRING, C1 : INTEGER).
• The middle child has a downward filled-circle couple labelled B1, which matches Modify(B1 : BOOLEAN).
• The middle child calls another module below it with R2, matching Update(BYREF R2 : STRING).
• The right child must therefore be Final(T1 : INTEGER).
• The lower right function returning a Boolean must be Confirm().

You must complete the chart with the module names, the missing couples and the iteration symbol.

Approach

Use the module headers and the partly drawn arrows together.

A reliable method is:

1. Identify which boxes must be procedures and which must be functions.
2. Match parameter names already shown in the diagram to the correct module header.
3. Put function return arrows back up to the caller.
4. Treat BYREF as data passed down and back up.
5. Add the iteration arc because Setup repeatedly calls the three modules underneath it.

The names of the parameters matter, because they tell you which module belongs in which position.

Step-by-Step Reasoning

First identify the three modules directly called by Setup.

The question says Setup repeatedly calls three modules, so the three boxes directly below Setup must be:

• Restart
• Modify
• Final

Now match them one by one.

1. Left child of Setup

   • The given diagram shows a downward data couple labelled H1 on the left branch.
   • Only Restart(H1 : STRING, C1 : INTEGER) has parameter H1.
   • So the left box is Restart.
   • Add the second downward data couple labelled C1 on the same branch.

2. Middle child of Setup

   • The branch already has B1 going down.
   • Only Modify(B1 : BOOLEAN) RETURNS INTEGER uses B1.
   • So the middle box is Modify.
   • Because Modify is a function, it must return an INTEGER back up to Setup, so add an upward return arrow from Modify to Setup.

3. Right child of Setup

   • The remaining direct child must be Final(T1 : INTEGER).
   • Add the downward data couple labelled T1 from Setup to Final.

Now complete the lower modules.

1. Module below Modify

   • The vertical connection is labelled R2.
   • Update(BYREF R2 : STRING) matches this exactly.
   • So the lower middle box is Update.
   • Because R2 is passed BYREF, show the data moving both down to Update and back up to Modify.

2. Module below Final

   • The remaining module is Confirm().
   • Confirm is a function returning BOOLEAN.
   • So the lower right box is Confirm.
   • Its Boolean result returns upward to Final as a control couple.

3. Repetition

   • The question says Setup will repeatedly call three modules.
   • Therefore draw the iteration arc across the three outgoing calls from Setup to Restart, Modify and Final.

The completed chart is:

Key Takeaways

• In a structure chart, the top module calls the modules beneath it.
• Procedure headers help identify modules that perform actions only.
• Function headers must include a return route back to the caller.
• Parameter names are often the easiest way to match a module header to a position in the chart.
• BYREF means the same data item can be altered and returned.
• An iteration symbol shows repeated execution of a group of module calls.

Common Mistakes

• Putting the modules in the wrong boxes, especially swapping Restart, Modify and Final.
• Forgetting that Modify is a function, so it must return a value upward to Setup.
• Forgetting that Confirm is also a function and returns upward to Final.
• Showing R2 only one way even though BYREF means it must travel down and back.
• Omitting C1 from the Restart call.
• Leaving out the iteration arc even though Setup repeatedly calls the three modules.

Things to Be Careful About

• Match the module names exactly: Setup, Restart, Modify, Final, Update, Confirm.
• Match the parameter names exactly: H1, C1, B1, T1, R2.
• Keep arrow direction correct: parameters down, function results up.
• Distinguish between data couples and control couples according to the chart notation given.
• Do not attach Update to the wrong parent; it belongs under Modify because of R2.
• Do not attach Confirm to Setup; it is called by Final.

Background Concept

A record stores several related fields together under one structure. Here, each Loan record contains a StudentID, a BookID and an OnLoan Boolean. The global array Loan contains many such records.

To decide whether a student can borrow another book, the program must count how many books that student currently has on loan. "Currently on loan" means OnLoan = TRUE. Returned books must not be counted.

For efficiency, when a question gives a limit such as "up to five books", a good algorithm does not always need to scan all 5000 records fully. If the count reaches 5, the answer is already known, so the loop can stop early.

Understanding the Question

The module OKToBorrow() is given one StudentID. It must search the whole Loan array for records belonging to that student and then output a message saying whether that student may borrow another book.

Important details from the stem:

• The array has 5000 elements.
• Unused elements have StudentID set to an empty string.
• Unused elements may occur anywhere in the array.
• A student may borrow up to 5 books at a time.

That last point means:

• fewer than 5 active loans -> may borrow
• 5 active loans -> may not borrow

Because unused entries can appear anywhere, you cannot stop just because you see an empty StudentID once.

Approach

Use a procedure, because the module description says it should output a suitable message rather than return a value.

The strategy is:

1. Start a counter at 0.
2. Scan through the array.
3. For each record, check two conditions:
   • the StudentID matches the parameter
   • OnLoan is TRUE
4. If both are true, increase the count.
5. Stop the loop early if the count reaches 5, because then the student definitely cannot borrow another book.
6. Output the correct message after the loop.

Step-by-Step Reasoning

PROCEDURE OKToBorrow(BYVAL SearchStudentID : STRING)

• This defines a procedure named OKToBorrow.
• The parameter is passed in as a string containing the student to search for.

DECLARE Index, LoanCount : INTEGER

• Index is needed to move through the array.
• LoanCount stores how many active loans this student currently has.

LoanCount ← 0

• The count must begin at zero before any records are checked.

Index ← 1

• The search starts at the first array element.

WHILE Index <= 5000 AND LoanCount < 5

• The loop continues while there are still array elements left.
• It also continues only while the count is still below 5.
• This second condition is the efficiency improvement: once 5 is reached, there is no need to keep searching.

IF Loan[Index].StudentID = SearchStudentID AND Loan[Index].OnLoan = TRUE THEN

• This checks that the record belongs to the required student.
• It also checks that the book has not yet been returned.
• Both are necessary: a returned book should not count towards the limit.

LoanCount ← LoanCount + 1

• If both conditions are true, increase the number of active loans for that student.

Index ← Index + 1

• Move on to the next record.

After the loop:

• If LoanCount < 5, the student still has room to borrow another book.
• Otherwise, the student has already reached the limit.

The output messages can be any clear equivalent wording, provided one message means the student can borrow and the other means the student cannot.

Key Takeaways

• Count only records that meet all the required conditions.
• A Boolean field such as OnLoan is often used to filter active records from inactive ones.
• An efficient search can stop early when the result is already known.
• Do not treat an empty array element as the end of data unless the question explicitly says the used records are contiguous.

Common Mistakes

• Counting all matching StudentID records, including returned books. This is wrong because only books still on loan count towards the limit.
• Stopping at the first empty StudentID. This is wrong because unused elements may occur anywhere in the array.
• Using a function instead of a procedure and forgetting the required output message.
• Allowing the loop to continue after reaching 5, which is less efficient than the question asks for.
• Using = instead of ← for assignment in pseudocode.

Things to Be Careful About

• The array size is 5000, so the loop bounds must cover all 5000 elements unless the early-exit condition is met.
• The comparison must use both the parameter value and the OnLoan field.
• The student may borrow another book only if the active count is strictly less than 5.
• Keep the identifier casing consistent, for example StudentID and OnLoan.
• In CIE pseudocode, write PROCEDURE, DECLARE, WHILE, ENDIF and ENDPROCEDURE in upper case.

Background Concept

A function is used when a module must return a value. Here, ReturnBook() must return either TRUE or FALSE, so it should be written as a Boolean function.

This question uses a record array search. A particular loan record is identified by a combination of two fields:

• StudentID
• BookID

That pair acts like a compound key for this task. The stem also states there can be no more than one record for a given student-book combination. That matters because once a match is found, the function can stop immediately.

Understanding the Question

The function receives two strings: one student ID and one book ID. It must:

• search the array for the matching loan record
• if found and the book is still on loan, set OnLoan to FALSE and return TRUE
• return FALSE if no such record exists
• also return FALSE if the matching record exists but the book has already been returned

The important clue is the word "efficient". Since there can be at most one matching record, there is no reason to continue searching after a match has been found.

Also, as in part (a), unused records may occur anywhere, so an empty StudentID cannot be used as a stopping point.

Approach

Use a linear search through the Loan array.

For each record:

1. Check whether both StudentID and BookID match the parameters.
2. If not, move on.
3. If they do match, inspect OnLoan:
   • if TRUE, change it to FALSE and return TRUE
   • if FALSE, return FALSE immediately because the book was already returned
4. If the loop finishes with no match, return FALSE

That structure is efficient because the function exits as soon as the answer is known.

Step-by-Step Reasoning

FUNCTION ReturnBook(BYVAL SearchStudentID : STRING, BYVAL SearchBookID : STRING) RETURNS BOOLEAN

• This defines a function because the module must return TRUE or FALSE.
• The two parameters are the identifiers used to locate the correct record.

DECLARE Index : INTEGER

• Only one loop variable is needed for the search.

Index ← 1

• Start from the first array element.

WHILE Index <= 5000

• Check every array element if necessary.
• There is no safe earlier stopping condition based on empty elements because unused entries may appear anywhere.

IF Loan[Index].StudentID = SearchStudentID AND Loan[Index].BookID = SearchBookID THEN

• This is the key matching test.
• Both fields must match, not just one of them.
• Matching only the student would be wrong because the student may have several loans.
• Matching only the book would be wrong because different students may borrow different books over time.

Inside the matching case:

IF Loan[Index].OnLoan = TRUE THEN

• The record exists, so now check whether the book is still currently on loan.

Loan[Index].OnLoan ← FALSE

• This updates the record to show the book has been returned.

RETURN TRUE

• The return was successful, so the function returns TRUE.
• The search stops immediately.

ELSE RETURN FALSE

• If the matching record exists but OnLoan is already FALSE, the book has already been returned.
• The question says this must return FALSE.
• Because only one such student-book combination can exist, the search can stop here as well.

If no match is found in the whole array:

RETURN FALSE

• This covers the case where the relevant loan record does not exist at all.

This function has three logical outcomes:

1. matching record found and updated -> TRUE
2. matching record found but already returned -> FALSE
3. no matching record found -> FALSE

Key Takeaways

• Use a function when a Boolean result must be returned.
• When two fields together identify a record, both must be checked in the condition.
• If the question guarantees at most one match, you can return immediately once it is found.
• Updating a record field in an array is done directly through the indexed record element.

Common Mistakes

• Searching using only StudentID or only BookID. This can return the wrong record.
• Setting OnLoan to FALSE without first checking whether it is already FALSE.
• Continuing to search after finding the matching record, even though the question states there can only be one.
• Returning TRUE when the record exists but the book has already been returned. The question explicitly says that case must return FALSE.
• Stopping on an empty StudentID, which is invalid because unused entries may appear anywhere.

Things to Be Careful About

• The function must be a FUNCTION, not a PROCEDURE, because it returns a Boolean value.
• The record field update must use assignment: Loan[Index].OnLoan ← FALSE.
• Make sure the final RETURN FALSE is present for the "not found" case.
• Keep the loop index increment outside the matching branch so the search progresses correctly when there is no match.
• Use the exact field names from the stem: StudentID, BookID, OnLoan.

Background Concept

When program requirements change, the data structures often have to change as well. In record-based designs, this usually means adding new fields or introducing another related record structure.

A good design stores data in a way that supports later processing. Here, the system is being extended to handle different loan lengths and fines. That means the program must know how long a loan is allowed to last, and that allowed length depends on the category of the book.

Understanding the Question

The question gives two new requirements:

1. each loan has a maximum length measured in days
2. each book belongs to one of three categories, and each category has a different maximum loan length

It asks for the necessary changes to record structure and program design. So this is not asking for full pseudocode. It wants the design changes that make these requirements possible.

Approach

There are two direct design consequences:

• the program must store the maximum permitted loan period
• the program must know the category of each book and connect that category to the correct loan length

So a complete outline should mention one data-structure change for the loan length and one design change for categories and how the program uses them.

Step-by-Step Reasoning

First requirement: each loan has a maximum length in days.

• The system needs somewhere to store that value.
• The simplest change is to add a field such as MaxLoanDays : INTEGER.
• That lets each loan record carry the allowed number of days.

Second requirement: each book belongs to one of three categories, each with a different maximum length.

• The program must store a category for each book, for example in a book record or related data structure.
• It must also store the permitted days for the three categories, for example as constants, an array, or another lookup structure.
• When a loan is created, or when overdue/fine logic runs, the program uses the book's category to determine the correct maximum loan length.

The key idea is that the category itself is not enough; the program also needs the mapping from category to number of days.

Key Takeaways

• New requirements often mean adding fields to records.
• If one item's behaviour depends on a category, the category and its rules must both be represented in the design.
• Data design and program logic must be changed together.

Common Mistakes

• Saying only "add a fine field". That does not meet the stated requirements about loan length and category.
• Adding only a category field but not explaining that each category needs a corresponding loan-length value.
• Mentioning program changes without any data-structure change, or vice versa.

Things to Be Careful About

• The question asks for changes needed for the two stated requirements, so keep the answer focused on those.
• A field storing days should use a numeric type such as INTEGER.
• The category data belongs with books, while the allowed loan period must also be available to the loan-handling logic.
• In an exam outline question, concise accurate design points score better than long vague descriptions.