Cambridge IGCSE™(9–1)

* 1 1 5 0 9 7 0 0 8 9 *

COMPUTER SCIENCE 0984/22

Paper 2 Algorithms, Programming and Logic May/June 2024

1 hour 45 minutes

You must answer on the question paper.

No additional materials are needed.

INSTRUCTIONS
● Answer all questions.
● Use a black or dark blue pen. You may use an HB pencil for any diagrams or graphs.
● Write your name, centre number and candidate number in the boxes at the top of the page.
● Write your answer to each question in the space provided.
● Do not use an erasable pen or correction fluid.
● Do not write on any bar codes.
● Calculators must not be used in this paper.

INFORMATION
● The total mark for this paper is 75.
● The number of marks for each question or part question is shown in brackets [ ].
● No marks will be awarded for using brand names of software packages or hardware.

This document has 16 pages. Any blank pages are indicated.

DC (PQ) 341260/1
© UCLES 2024 [Turn over
 2

1 Tick (✓) one box to identify a method used to design and construct a solution to a computing
problem.

A analysis

B coding

C flowchart

D testing
[1]

2 Four logic functions and five standard symbols for logic gates are shown.

Draw one line to link each logic function to its standard symbol. Not all standard symbols will be
used.

Logic function Standard symbol

AND

XOR

NAND

OR

[4]

3 Identify three different tasks in the analysis stage of the program development life cycle.
Final details
1 .......................................................................................................................................................
One mark for each correct answer max three
MP1 abstraction
MP2 decomposition
..........................................................................................................................................................
MP3 identification of problem
Plan MP4 identification of requirements // outline of success criteri
2 .......................................................................................................................................................

..........................................................................................................................................................
Create a visual representation of the program with structure charts, pseudocode, flowcharts...
3 .......................................................................................................................................................

..........................................................................................................................................................
[3]

© UCLES 2024 0984/22/M/J/24

 3

4 A program needs to make sure the characters input for a product code meet these rules:

• The product code is six characters in length.

• The first two characters must be “PD”.
• The last four characters must be a number in the range 1000 to 9999 inclusive.

(a) Identify three validation checks and state how each check would make sure the product code
met one of these rules.
Length check to make sure it is 6 characters in length
Check 1 ....................................................................................................................................

...................................................................................................................................................

...................................................................................................................................................
Format check to make sure the first two characters are "PD"
Check 2 ....................................................................................................................................

...................................................................................................................................................

...................................................................................................................................................

Check 3 ....................................................................................................................................
Range check to make sure the numbers are between 1000 and 9999

...................................................................................................................................................

...................................................................................................................................................
[6]

(b) The program design will include a pseudocode algorithm. Assume that the product code is
stored in the variable Product

(i) Write the pseudocode to make sure that the product code is six characters in length.
DECLARE ProductCode: STRING
...........................................................................................................................................
REPEAT
OUTPUT "Enter the product code"
...........................................................................................................................................
INPUT ProductCode
UNTIL LENGTH(ProductCode) = 6
...........................................................................................................................................

...........................................................................................................................................

..................................................................................................................................... [2]

(ii) Write the pseudocode to make sure that the first two characters of the product code are
“PD”.

...........................................................................................................................................
DECLARE ProductCode: STRING
REPEAT
OUTPUT "Enter the product code"
...........................................................................................................................................
INPUT ProductCode
UNTIL SUBSTRING(ProductCode,1,2) = "PD"
...........................................................................................................................................

...........................................................................................................................................

..................................................................................................................................... [2]

© UCLES 2024 0984/22/M/J/24 [Turn over

 4

5 A high-level programming language makes use of arithmetic, Boolean and logical operators.

State how each type of operator is used.

Give an example statement, in pseudocode, for each one.
To carry out arithmetic operations like + - x / ....
Arithmetic .........................................................................................................................................

..........................................................................................................................................................
Calc <- 20 + 40
Example ...........................................................................................................................................

..........................................................................................................................................................

A condition which can only have 2 values ( TRUE and FALSE)

Boolean ............................................................................................................................................

..........................................................................................................................................................

Flag <- TRUE

Example ............................................................................................................................................

..........................................................................................................................................................
comparisons/conditional statements/selection statements
Used in gates, conditions for values to be 0 or 1
Logical ..............................................................................................................................................

..........................................................................................................................................................

IF Size = "Big" AND "Heavy"

Example ...........................................................................................................................................

..........................................................................................................................................................
[6]

© UCLES 2024 0984/22/M/J/24

 5

6 Totalling and counting are standard methods of solution.

Numbers are input. The number 9999.9 is the last number to be input and is ignored.

(a) Write an algorithm in pseudocode to total the numbers input and to output the total.
You do not need to validate the input.
REPEAT
...................................................................................................................................................
INPUT Number
IF Number =! 9999.9
...................................................................................................................................................
THEN
Total <- Total + Number
UNTIL Number = 9999.9
...................................................................................................................................................
OUTPUT Total
...................................................................................................................................................

...................................................................................................................................................

...................................................................................................................................................

...................................................................................................................................................

...................................................................................................................................................

............................................................................................................................................. [4]

(b) Write an algorithm in pseudocode to count and output the number of input values that are
greater than 100. You do not need to validate the input.

WHILE Number =! 9999.9 DO

...................................................................................................................................................
INPUT Number
IF Number> 100
...................................................................................................................................................
THEN
Count <- Count + 1
...................................................................................................................................................
END IF
ENDWHILE
...................................................................................................................................................
OUTPUT Count

...................................................................................................................................................

...................................................................................................................................................

...................................................................................................................................................

...................................................................................................................................................

...................................................................................................................................................

............................................................................................................................................. [4]

© UCLES 2024 0984/22/M/J/24 [Turn over

 6

7 An algorithm has been written in pseudocode to find and display the maximum and minimum
values in an array of 1000 positive numbers. The array List[] starts at index 1

01 Max List[1]
02 Min List[1]
03 FOR Counter 2 TO 1000
04 IF List[Counter] < Max
05 THEN
06 Max List[Counter]
07 ENDIF
08 IF List[Count] ˂ Min
09 THEN
10 Min List[Counter]
11 ENDWHILE
12 NEXT Counter
13 OUTPUT "Maximum value is ", Max
14 OUTPUT "Minimum value is ", Min

(a) Give a line number for each of these types of statement:

Line 1
Assignment statement ..............................................................................................................
Line 4
Selection statement ..................................................................................................................
Line 3
Iteration statement ....................................................................................................................
[3]

(b) Identify the line numbers of the three errors in the pseudocode and suggest a correction for
each error.

Error 1 line number ...................................................................................................................

4

IF List[Counter] > Max

Correction .................................................................................................................................

...................................................................................................................................................
8
Error 2 line number ...................................................................................................................
IF List[Counter] < Min
Correction .................................................................................................................................

...................................................................................................................................................
11
Error 3 line number ...................................................................................................................
END IF
Correction .................................................................................................................................

...................................................................................................................................................
[3]

© UCLES 2024 0984/22/M/J/24

 7

8 A logic circuit is to be built to control the opening of a safe used to store money. There are two
keys, A and B, and a time switch C. The safe can only open if both keys are used and the time
switch is off.

not used 0
key A
used 1

not used 0
key B
used 1

switch off 0
time switch C
switch on 1

safe cannot open 0

safe X
safe can open 1

(a) Write the logic expression for this problem.

............................................................................................................................................. [3]

(b) Complete the truth table for this problem.

Working space
A B C X

0 0 0

0 0 1

0 1 0

0 1 1

1 0 0

1 0 1

1 1 0

1 1 1

[4]

© UCLES 2024 0984/22/M/J/24 [Turn over

 8

9 This flowchart represents an algorithm.

START

A FALSE
B 1

IS List[B] > No
T List[B]
List[B + 1]?

Yes
List[B] List[B + 1]

List[B + 1] T

A TRUE

B B+1

No IS B =
5?

Yes

Yes IS A =
TRUE?

No

STOP

(a) The array List[1:5] used in the flowchart contains this data:

List[1] List[2] List[3] List[4] List[5]

15 17 20 5 9

© UCLES 2024 0984/22/M/J/24

 9

Complete the trace table using the data given in the array.

A B List[1] List[2] List[3] List[4] List[5] T

15 17 20 5 9

[5]

(b) Describe what the algorithm represented by the flowchart is doing.

-It is using the principal of bubble sort
...................................................................................................................................................
-It is sorting the numbers in descending order
...................................................................................................................................................

...................................................................................................................................................

............................................................................................................................................. [2]
© UCLES 2024 0984/22/M/J/24 [Turn over
 10

10 A television subscription service has a new database table named Contract to store details of
their subscribers’ contracts. The table contains these fields:

• ContractNumber – the contract number, for example CT567

• Months – the length of the contract in months, for example 6
• EndDate – the date the contract finishes, for example 30 November 2024
• News – the news service, yes or no
• Movie – the movie service, yes or no
• Sport – the sports service, yes or no
• Junior – the children’s service, yes or no.

(a) Identify the field that will be the most appropriate primary key for this table.
ContractNumber
............................................................................................................................................. [1]

(b) Complete the table to identify the most appropriate data type for these fields in Contract

Field Data type

ContractNumber alphanumeric

Months integer

EndDate date/time

Sport boolean
[2]

(c) Explain the purpose of these structured query language (SQL) statements.

Statement 1: SELECT SUM (Months) FROM Contract;

Statement 2: SELECT COUNT (News) FROM Contract WHERE News;

Adds up the total amount of months within all contracts
Statement 1 ..............................................................................................................................

...................................................................................................................................................

...................................................................................................................................................
Shows how many users have the news service in their contract
Statement 2 ..............................................................................................................................

...................................................................................................................................................

...................................................................................................................................................
[3]

© UCLES 2024 0984/22/M/J/24

 11

(d) Complete this SQL statement to find the contract numbers of the subscribers that take both
the news and sports services.
ContractNumber
SELECT .....................................................................................................................................

FROM Contract
News = TRUE
WHERE .......................................................... Sport = TRUE
AND ................................................................. ;
[2]

© UCLES 2024 0984/22/M/J/24 [Turn over

 12

11 A one-player game uses the two-dimensional (2D) array Grid[] to store the location of a secret
cell to be found by the player in 10 moves. Each row and column has 5 cells.

Start
Grid[1,1]

At the start of the game:

• The program places an ‘X’ in a random cell (not in Grid[1,1]) and empties all the other
cells in the grid.
• The player starts at the top left of the grid.
• The player has 10 moves.

During the game:

• The player can move left, right, up or down by one cell and the move must be within the grid.
• “You Win” is displayed if the player moves to the cell with ‘X’ and has played 10 moves or
less.
• “You Lose” is displayed if the player has made 10 moves without finding the ‘X’.

Write a program that meets these requirements.

You must use pseudocode or program code and add comments to explain how your code works.

You do not need to declare any arrays or variables; you may assume that this has already been
done.

All inputs and outputs must contain suitable messages.

FOR Row <- 1 TO 5
..........................................................................................................................................................
FOR Column <- 1 TO 5
Grid[Row,Column] <- ""
//All grids are emptied
..........................................................................................................................................................
NEXT Column
NEXT Row
x <- RANDOM (1,5)
..........................................................................................................................................................
y <- RANDOM (1,5) // X is assigned to a random cell
Grid[x,y] <- "X"
..........................................................................................................................................................
i <- 1
Start is assured to be at the top left of the grid
j <- 1
..........................................................................................................................................................
Move <- 0 // This iteration allows for the 10 moves from the player
REPEAT
..........................................................................................................................................................
REPEAT
OUTPUT "Enter your move: w to go up, s to go down. d to go to the right and a to go to the left"
INPUT Move
..........................................................................................................................................................
CASE OF UCASE(Move)
"W": j <- j + 1
..........................................................................................................................................................
"S": j <- j - 1
// Validation so it doesn't go out of the grid is done
"D": i <- i + 1
..........................................................................................................................................................
"A": i <- i - 1
UNTIL i>= 1 AND j>= 1
© UCLES 2024 0984/22/M/J/24
 13

..........................................................................................................................................................
IF Grid[i,j] <- "X"
THEN //Winning and loosing is checked and output
OUTPUT "You win"
..........................................................................................................................................................
END IF
Move <- Move + 1
..........................................................................................................................................................
UNTIL Grid[i,j] <- "X" OR Move = 10

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................
© UCLES 2024 0984/22/M/J/24 [Turn over
 14

..........................................................................................................................................................
Grid [XRow, XColumn] 'X'
..........................................................................................................................................................
MaxMove 10
NumberMoves 0
..........................................................................................................................................................
PlayerRow 1
PlayerColumn 1
..........................................................................................................................................................
Win FALSE

// during game
..........................................................................................................................................................
WHILE NumberMoves < MaxMove AND NOT Win
MoveError FALSE
..........................................................................................................................................................
OUTPUT "Please enter your move, L – Left, R – Right, U – Up or D - Down"
INPUT UPPER(PlayerMove)
..........................................................................................................................................................
REPEAT
CASE OF PlayerMove
'L' : TempColumn PlayerColumn – 1
..........................................................................................................................................................
'R' : TempColumn PlayerColumn + 1
'U' : TempRow PlayerRow – 1
..........................................................................................................................................................
'D' : TempRow PlayerRow + 1
OTHERWISE MoveError TRUE
..........................................................................................................................................................
ENDCASE

// check for out-of-range moves

..........................................................................................................................................................
IF TempColumn < 1 or TempColumn > 5
THEN
..........................................................................................................................................................
MoveError TRUE
ELSE
..........................................................................................................................................................
PlayerColumn TempColumn
ENDIF
..........................................................................................................................................................
IF TempRow < 1 or TempRow > 5
THEN
..........................................................................................................................................................
MoveError TRUE
ELSE
..........................................................................................................................................................
PlayerRow TempRow
ENDIF
..........................................................................................................................................................
// check win if X Found
IF Grid [PlayerRow, PlayerColumn] = 'X'
..........................................................................................................................................................
THEN
OUTPUT "You Win"
..........................................................................................................................................................
Win TRUE
ELSE
IF NOT MoveError
..........................................................................................................................................................
THEN
NumberMoves NumberMoves + 1
..........................................................................................................................................................
ENDIF
ENDIF
..........................................................................................................................................................
UNTIL NOT MoveError
ENDWHILE
..........................................................................................................................................................
IF NOT Win
THEN
..........................................................................................................................................................
OUTPUT "You Lose"
ENDIF
..........................................................................................................................................................

..........................................................................................................................................................

..........................................................................................................................................................

.................................................................................................................................................. [15]
© UCLES 2024 0984/22/M/J/24
 15

BLANK PAGE

FOR Rows <- 1 TO 5

FOR Columns <- 1 TO 5
Grid[Rows, Columns] <- ""
NEXT Columns
NEXT Rows
REPEAT
x <- RANDOMBETWEEN(1,6)
y <- RANDOMBETWEEN(1,6)
UNTIL x <> 1 AND y <> 1
Grid[x,y] <- "X"
TempRow <- 1
Row <-1
TempColumn <- 1
Column <- 1
MoveCounter <- 0
ErrorMove <- FALSE
Win <- FALSE

WHILE Win = FALSE AND MoveCounter < 10 DO

REPEAT
TempRow <- Row
TempColumn <- Column
OUTPUT "Enter your move: W to go up, S to go down, A to go left and D to go right"
INPUT Move
CASE UCASE(Move)
"W": TempRow <- TempRow -1
"S": TempRow <- TempRow + 1
"A": TempColumn <- TempColumn -1
"D": TempColumn <- TempColumn + 1
OTHERWISE
ErrorMove <- TRUE
IF TempRow < 1 AND TempRow > 5
THEN
ErrorMove <- TRUE
ELSE
IF TempColumn < 1 AND TempColumn > 5
THEN
ErrorMove <- TRUE
END IF
UNTIL ErrorMove = FALSE

Row <- TempRow

Column <- TempColumn

IF Grid[Row,Column] <- "X"

THEN
OUTPUT "You Win"
Win <- TRUE
END IF
MoveCounter <- MoveCouter + 1
ENDWHILE

IF Win = FALSE
THEN
OUTPUT "You Lose"
END IF
© UCLES 2024 0984/22/M/J/24
 16

BLANK PAGE

Permission to reproduce items where third-party owned material protected by copyright is included has been sought and cleared where possible. Every
reasonable effort has been made by the publisher (UCLES) to trace copyright holders, but if any items requiring clearance have unwittingly been included, the
publisher will be pleased to make amends at the earliest possible opportunity.

To avoid the issue of disclosure of answer-related information to candidates, all copyright acknowledgements are reproduced online in the Cambridge
Assessment International Education Copyright Acknowledgements Booklet. This is produced for each series of examinations and is freely available to download
at www.cambridgeinternational.org after the live examination series.

Cambridge Assessment International Education is part of Cambridge Assessment. Cambridge Assessment is the brand name of the University of Cambridge
Local Examinations Syndicate (UCLES), which is a department of the University of Cambridge.

© UCLES 2024 0984/22/M/J/24