Computer Science 9618/21 — May/June 2022

Background Concept

An algorithm is a finite sequence of clearly defined steps used to solve a problem or complete a task. In Computer Science, a flowchart, structured English and pseudocode are all different ways of representing an algorithm.

A flowchart is not the algorithm itself; it is a diagram showing the algorithm. The underlying idea being described is still the sequence of steps, and the technical term for that is algorithm.

Understanding the Question

The question says a programmer draws a flowchart to show the sequence of steps needed to solve a problem. It then asks for the technical term for that sequence of steps.

The important clue is the phrase "sequence of steps ... to solve a problem". That definition matches algorithm exactly.

Approach

For a definition question like this, match the wording in the question to the standard Computer Science term.

• "sequence of steps"
• "solve a problem"

That pair of ideas points directly to algorithm.

Step-by-Step Reasoning

A flowchart is a way of representing the logic of a solution.

The solution itself, when described as an ordered set of steps, is called an algorithm.

So the correct technical term is:

• algorithm

Key Takeaways

• An algorithm is a step-by-step method for solving a problem.
• A flowchart is one way to show an algorithm.
• In exam questions, definition wording is often a direct clue to the required term.

Common Mistakes

• Writing "flowchart" instead of "algorithm". A flowchart is the diagram, not the step sequence itself.
• Writing "program". A program is coded implementation; the question is asking for the abstract step-by-step method.

Things to Be Careful About

• Read exactly what is being named: the representation or the thing being represented.
• Here, the flowchart shows the sequence of steps, so the answer is not the diagram type, but the underlying concept: algorithm.

Background Concept

This question tests expression evaluation in pseudocode. That includes several different ideas:

• arithmetic operations such as division and addition
• built-in functions such as INT, MID, TO_UPPER and NUM_TO_STR
• Boolean operators such as AND and NOT
• modulus using MOD

Key function meanings:

• INT(x) returns the integer part of a number
• TO_UPPER(text) converts letters to uppercase
• MID(text, start, length) returns a section of a string
• NUM_TO_STR(number) converts a numeric value into a string
• MOD returns the remainder after division

In Cambridge pseudocode, string positions are counted from 1.

Understanding the Question

You are given four separate expressions and must write the value each one produces.

This is not about writing code; it is about reading pseudocode accurately and applying the functions and operators in the correct order.

The four expressions test different skills:

• numeric evaluation with INT
• string processing with TO_UPPER and MID
• Boolean logic with AND and NOT
• remainder and type conversion with MOD and NUM_TO_STR

Approach

Take each expression one stage at a time.

1. Evaluate the innermost part first.
2. Apply any function to that result.
3. Keep track of the data type of the result.

For example, if the final operation is NUM_TO_STR, the result is a string, not a number.

Step-by-Step Reasoning

1. INT((31 / 3) + 1)

Start with the brackets:

$$31 \div 3 = 10.333\ldots$$

Then add 1:

$$10.333\ldots + 1 = 11.333\ldots$$

Now apply INT.
For a positive number, INT removes the fractional part, leaving:

$$11$$

So the evaluation is 11.

2. MID(TO_UPPER("Version"), 4, 2)

First apply TO_UPPER:

• "Version" becomes "VERSION"

Now number the characters using 1-based indexing:

• 1 = V
• 2 = E
• 3 = R
• 4 = S
• 5 = I
• 6 = O
• 7 = N

MID(text, 4, 2) means start at character 4 and take 2 characters.
That gives:

• character 4 = S
• character 5 = I

So the result is SI.

3. TRUE AND (NOT FALSE)

Start inside the brackets:

• NOT FALSE = TRUE

Now the expression becomes:

• TRUE AND TRUE

AND is only TRUE if both sides are TRUE, so the result is:

• TRUE

4. NUM_TO_STR(27 MOD 3)

First find the remainder when 27 is divided by 3.

Since 27 divides exactly by 3, the remainder is:

• 0

Now apply NUM_TO_STR.
This converts the number 0 into the string "0".

So the final result is "0".

Key Takeaways

• Evaluate expressions from the inside outward.
• INT removes the fractional part.
• MID uses a start position and length, and string positions are 1-based.
• NOT changes FALSE to TRUE and vice versa.
• MOD gives a remainder.
• NUM_TO_STR changes a numeric result into text.

Common Mistakes

• Writing 10 for the first expression by applying INT too early to 31 / 3 before adding 1.
• Using 0-based indexing for MID and getting the wrong substring.
• Forgetting to apply TO_UPPER before taking the substring.
• Writing 0 instead of "0" for NUM_TO_STR(27 MOD 3), which loses the fact that the final result is a string.
• Evaluating TRUE AND (NOT FALSE) as FALSE by mishandling NOT.

Things to Be Careful About

• Keep track of data type as well as value.
• In string questions, check carefully whether positions start at 0 or 1; here they are 1-based.
• INT is applied after the whole bracketed expression is found.
• MOD does not mean division result; it means remainder.
• When a conversion function is used, make sure your final answer matches the converted form.