Data Structures

Examiner’s Comments

Many responses were too vague, showing little knowledge of the properties of arrays. Relatively few candidates appeared to be able to make explicit links to the scenario to achieve full marks.

BP1 Do not award procedure or method

BP1 Allow self as an additional parameter if Python is used.

BP1 If an access modifier is given for the method, it must be public and not private.

BP2 Do not allow any modified name attribute to be returned.

Examiner’s Comments

While many candidates had little difficulty giving code for a getter() there were a number of common errors. Some candidates used a private access modifier when a getter() needs to be public. There was often erroneous use of ‘procedure’ whereas a getter() is a function that must return a value.
Some candidates tried to set values within the getter() function when it should only have returned the class attribute value.

MP2 allow any order of parameters

"Box" and "Money" must be strings and 25 must be an integer

Allow prize.new() as new is given as the constructor method in the class diagram

Examiner’s Comments

Many candidates struggled with the instantiation of an object. Where candidates made an attempt to instantiate some did not use a string for “box” and “money” or did not give 25 as an integer but instead gave the string “25”.

Give:

• 1 mark for stating a decision
• 1 mark for the action required if true
• 1 mark for the action required if false

Examiner’s Comments

There were only two reasonable decisions that could be given from the scenario details. Candidates needed to make it clear that a decision with a Boolean output was present that would dictate two potential outcomes. Some candidates quoted actions such as ‘randomly assign space for prize’ which did not represent a decision. Many responses described the mechanics of setting up the game and the random spaces but did not highlight the program conditions/decisions as required.

Allow minor changes to identifiers as long as purpose is clear.

Allow

procedure new(pName)
this.name = pName

…
(or similar e.g. self.name)

Allow two parameters if one is self and the response is clearly in Python.

The parameter name should be different to the attribute name.

Examiner’s Comments

It was clear that those candidates with limited OOP programming knowledge found the writing of a relatively simple constructor method difficult. Those with relevant programming experience often found this to be a very straightforward question. Common errors included passing additional values to set the experience, roadPosition and money attributes rather than setting them to the constant values indicated in the question.

Do not allow Function for BP1

BP2 parameters must be given in the correct order to match the calls to updateValues() in the question.

“money” and “experience” must be string values

Examiner’s Comments

The updateValues procedure again proved problematic for candidates with limited OOP experience. No marks were given for the first mark point if a function was declared as there was no return value. Parameter names needed to be fit for purpose, understandable,

and had to match the order given in the question scenario to work for the given example calls.

Allow road.length / len(road) instead of 50

Allow <=49 instead of < 50

Examiner’s Comments

Nearly all candidates achieved some marks, and a majority scored five or six marks.

Line 07 allow print(road[x].name)

Examiner’s Comments

Many candidates scored three or four marks but in general candidates found it harder to identify errors in the code than to complete code in the previous question. Some candidates didn’t give the line number but rewrote the incorrect line before giving the corrected line, which was acceptable, although not ideal given the scaffolding.

AO1: Knowledge and Understanding
Indicative content

• Global variables are created when the program starts, all subroutines can access/update the contents

• Local variables are created in the subroutine they are created in, they are not accessible directly from any other subroutine

• Local variables are removed from memory when the subroutine ends.

• Local variables can be passed as parameters to a function to be updated, and then returned to override the original local variable

• Local variables can be passed by reference to a subroutine to allow the content of the variable to be updated

AO2: Application

• The variables will be stored in memory throughout the whole code execution. However, the amount of data they are storing is relatively low so would not use a lot of memory.
• When the game is expanded, the amount of data may increase so it could be memory intensive, especially if graphics are used in the game.
• Both arrays are needed throughout the whole game so keeping them as global will make writing the code easier as the programmer will not need to keep passing them as parameters and setting return values.
• Only one part of the game is being created initially and therefore the use of global variables would not affect the efficiency greatly. However, when the program expands, it could cause accuracy / testing / debugging and maintenance problems.

AO3: Evaluation

• As this is only a prototype, the use of global variables would be beneficial.
• However, when the game expands, the use of global variables could create issues such as running out of memory, coupling, testing & debugging problems and maintenance problems.
• The programmer may be best to keep the variables as local and then pass them between the different subroutines as parameters byVal and byRef.

Examiner’s Comments

Most responses were Level 2 for definitions and some expansion to passing parameters. Very few candidates were able to go into depth about alternatives to global variables such as passing by value and passing by reference in detail or extending to issues such as scalability within a larger more extended game. Few candidates picked up on the fact that this was a more limited prototype that was likely to be expanded on which would require more consideration to be given to variable scope.

For MP1 accept any suitable attempt at typing as an array, for example towns = [], towns( )

For MP2 accept any suitable attempt to set to 2

dimensions of the correct size

Allow 7, 2 as array index

Allow column major notation
i.e. array towns [3,8]

Examiner’s Comments

Many candidates were able to gain full marks with most being able to gain one. Many candidates did not specify the number of elements in the array which was given in the question and tended to give responses such as towns = [ ] and as such only gained one mark.

If same town added more than once BOD if one in the right place

Ignore basic spelling mistakes and case

Towns must be to left or right of the node above - DNA nodes straight below.

Examiner’s Comments

This was generally well answered and many candidates gained full marks with many candidates writing out the alphabet beneath the question to aid then in placing the new towns.

All string values must be in quotes. Allow single or double quotes.

Don’t allow single = for MP1&2. Penalise once and FT for multiple occurrences.

Case needs to match that used in the question

Needs to have brackets for MP3

do
value = input("Enter a value")

if value == "E" then
num = numbers.pop()
print(num)
elseif value == "A" or value == "S" then
numone = numbers.pop()
numtwo = numbers.pop()
if value == "A" then
numbers.push(numone + numtwo)
elseif value == "S" then
numbers.push(numtwo - numone)
endif
else
numbers.push(value)
endif
until value == "E"

Examiner’s Comments

Generally well answered with most candidates being able to gain between 2 and 5 marks on this question.

One mark per stack diagram

Examiner’s Comments

This question was generally well answered although some candidates struggled to understand the concept of a stack and how data is pushed on to it and popped from it.

Examiner’s Comments

This was generally well answered, with the biggest misunderstanding being the way the subtraction occurs.

Examiner’s Comments

Many candidates were able to gain at least one mark on this question for stating that the addition would only be able to pop one number. The candidates who gained full marks were able to state the type of error correctly and explain why there was only one value able to be popped after the subtraction.

Mark in pairs

Accept descriptions of LIFO / FIFO for MP1 and 2

Examiner’s Comments

Generally well answered with the most popular answer being that a stack is LIFO and a queue is FIFO.

Mark in pairs

Examiner’s Comments

Generally well answered, although some candidates confused a list with a linked list.

Examiner’s Comments

Generally well answered, with a tuple being immutable being the most common answer.

Accept answers relating to locations given by pointers

Allow acceptable diagram illustrating the same points

Examiner’s Comments

For this question candidates were asked how the second item in a linked list would be accessed using the pointers but many just gave descriptions of a linked list having pointers and data without saying how the data in the second item would be accessed.

Note: Answers must relate to an array implementation which means that a stack pointer must be implemented.

Examiner’s Comments

Candidates need to be mindful of the fact that an array is a static data structure with a predetermined size. This meant that responses that explained how lists could be used to append and remove items were not given marks. This is an area where candidates who only have programming experience of using lists in Python often struggle.

Implementing a stack in an array requires a stack pointer. Those candidates who appreciated this and who clearly had practical experience of modelling
push()/pop() operations on a stack were able to articulate how the stack would access array locations at the stack pointer.

Exemplar 3

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

A candidate's handwritten answer:

you can create a one dimensional array overlay two pointers under values pointing to the first as the bottom and then another pointing to the last of the top. if an item is popped the item with the under position of the top is deleted and the top pointer's value decreases by one. if you want to add an item you append to the list to the "position" of the top then you should check if top pointer = bottom pointer, no stack is empty, and if (top + 1) is greater than the length of the array to see if the stack is full.

This exemplar was one of the few responses to show a clear insight as to how an array can be used to store and access a stack. It makes it clear that a stack pointer is required and goes on to explain how the stack pointer is manipulated when push()/pop() operations are performed.

[An examiner's marking symbol, not shown here.]

Misconception

Many candidates were not clear about the difference between an array and a list:

• An array is a static structure whose size cannot be changed.
• Lists are dynamic and support items being removed or appended.

Examiner’s Comments

Most candidates correctly identified that a queue is a ‘First in First Out’ data structure.

Accept:

Examiner’s Comments

This question was generally answered well with most candidates achieving both marks. Some candidates did not correctly dequeue from the front of the queue, or enqueue to the rear.

Examiner’s Comments

Many candidates were given full marks for this question, although some did not correctly return ‘item’ and incorrectly stated ‘items’ would be returned.

Example solution

function reverse(name)
  reverseName = ""

  for nameCount = 0 to name.Length–1
    theStack.push(name[nameCount])
  next nameCount

  for nameCount = 0 to name.Length–1
    reverseName = reverseName +
theStack.pop()
  next nameCount

  return reverseName
end function

Give full marks for alternative solutions that would work fully.

Allow FT for any duplicate identifiers named incorrectly or using the incorrect case

Examiner’s Comments

Although some candidates answered this question well, others were only given 1 or 2 of the available 7 marks. Many candidates that lost marks did not push and/or pop characters correctly, and many did not return a value for the final mark. Candidates should also be reminded that the correct spelling and case of identifiers are required in questions of this type. Some candidates added spaces in identifier names or used a different case to the identifiers stated in the question and therefore, were not given marks.

[An examiner's marking symbol, not shown here.]

Assessment for learning

Candidates need to understand the importance of maintaining the spelling, case and use of spaces etc in identifiers in questions which ask for functions to be written.

Examiner’s Comments

The concept of having a single indexable identifier seemed to be poorly understood with few candidates gaining the mark. While many candidates understood that an array can be iterated through, they did not link this to the fact that elements in an array are indexable. Similarly, unqualified points such as ‘an array is easier to sort’ were not given marks for the same reason.

There was a common misconception that an array would use far less memory space than 50 separate variables. There would be minimal difference since each separate value would take the same amount of storage space as the corresponding value in an array. The only overhead for separate variables would be the extra pointers to the memory locations for each, compared to one pointer for an array.

Examiner’s Comments

Very few candidates had a clear grasp of the relevant terminology to clearly identify that an edge/arc is given a specific direction in a directed graph. Many responses either erroneously talked about paths between nodes (too vague as there can be many routes between two nodes located in different parts of a graph) or graphs being weighted.

Allow answers where candidates have given the reverse. e.g. a tree does not have loops.

Examiner’s Comments

Most candidates gave clear responses that indicated either that a tree has a root whereas a graph does not, or graphs can contain cycles whereas trees do not. There were a surprising number of candidates who thought trees were limited to a maximum of two child

nodes, showing a lack of understanding of generalised tree structures with hierarchies (e.g. directory tree).

Allow other suitable answers that are in context of the problem

Examiner’s Comments

Very few candidates were able to give suitable answers within the context of the problem. The question was asking why the graph in Fig 5 was a visualisation. Few candidates identified that it was because the letters at the nodes represented delivery addresses, while the weights on the edges represented the road distances between the addresses. Most candidates gave descriptions of visualisation in general rather than answering in context.

Examiner’s Comments

Many candidates found it easier to describe a benefit than to give a drawback. The most commonly identified benefit was that the array would have global scope (and would therefore not need to be passed as a parameter), but often the descriptions given were too vague, e.g. ‘can be accessed anywhere’. The correct technical vocabulary is required.

Drawbacks were poorly described. Potential side effects and resultant complexity debugging were frequently alluded to as ‘accidental change’ but not fully developed

into complete qualified points.

There was also a frequent misconception that you cannot have multiple variables with the same name, which is not true. When a local variable is declared with the same name as a global variable that already exists, it takes precedence within the local scope.

Examiner’s Comments
Candidates who successfully identified that a remainder was calculated found it harder to determine that its purpose was to see if the number was even or odd.

[An examiner's marking symbol, not shown here.]

Misconception

Some candidates think that a modulo division calculation resulting in 0 means that there is no remainder. Where the result of modulo division is 0 it means that the remainder is 0.

Examiner’s Comments
This question was generally not well answered. Candidates found it difficult to articulate a clear and concise set of steps that take place during a linear search. Many responses were vague and not directly related to a linear search being performed on the data presented in the table.

Example solution:

function findFirst()
   count = 0
   do
     found = false
     if customerID[2, count] == "" then
       found = true
     else
       count = count + 1
     endif
   until count == 10 or found == true
   if found == True
     return customerID[0,count]
   else
     return -1
   endif
endfunction

There are many different ways that this function could have been achieved. Therefore other alternative methods should be given credit.

Examiner’s Comments
A number of candidates started by defining a procedure rather than defining a function. Indentation was not always consistent with the constructs being used. Candidates seemed to have difficulty with referencing two dimensional structures. Algorithms that require two dimensional data frequently appear on this paper and candidates need to have extensive practical
programming experience solving problems using these structures.

Exemplar 2

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

approximations = [array]
function FindFirst(target):
    length = length(approximations)
    maximum = -1
    index = 0
    found = False
    while found == False and index < length:
        if approximations[index] == target:
            maximum = maximum
            maximum = approximations[index]
            found = True
            break
        index = index + 1
    return
    index
    end while
    return
    maximum
    end function

A well-structured pseudocode response that uses indentation and variable naming well. The logic of the loop to check each item in sequence for an empty entry is clear, as is the indexing into the 2-Dimensional table structure.

Exemplar 3

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

A candidate's handwritten answer:

[unclear] [unclear] [unclear] [unclear] If [unclear] appointments available, find first appointment available, if [unclear] [unclear] // If not one appointment [unclear] appointment available, plus is the first [unclear] appointment // If this prints the first appointment. If not no appointments available, return [unclear] [unclear] [unclear]

To contrast with Exemplar 2, this exemplar shows a lack of pseudocode with a response written mostly in prose English, with inconsistent indentation and a lack of clear variable naming.

[An examiner's marking symbol, not shown here.]

Assessment for learning

Candidates frequently benefit from having extensive practical programming experience when answering pseudocode questions.

Past paper questions can provide a context for problems for implementation. For this question candidates could either be asked to code a two dimensional table structure for the data in Fig 1 and to then implement the linear search, or they code be provided with a scaffolded partially complete solution with the table defined and the stem of a function given.

Routinely taking past paper questions that can be practically implemented is an effective way to make sure that candidates have relevant experience.

Marks should be awarded for correct swapping of adjacent items that are out of order. Therefore if the previous step is incorrect but the candidate has followed through with the correct answer then marks should be awarded.

Examiner’s Comments
There were a number of responses that included clear diagrams illustrating the first pass of a bubble sort on the given data. Very few candidates confused bubble

sort with other types of sorting algorithm so most achieved full marks for this question.

Correct answer only

Example answer

new = input("enter a name : ")
if top <=5 then
    top = top + 1
    wNames[top] = new
end if

[Image redrawn from the original mark scheme by an AI model (Gemma 4 12B). It may contain mistakes.]

flowchart TD
    K["Kirstie"] ---|left| A["Alex"]
    K ---|right| M["Martyn"]
    A ---|left| B[" "]
    A ---|right| C["Anna"]
    M ---|left| D["Louise"]
    M ---|right| E[" "]

Allow FT from b(i)

Allow reference to big O for second mark.
Linked List O(n), Binary Tree O(log n)

Allow reference to big O for second mark.
Binary tree O(log n) Hash table O(1)

Allow the reverse ordering from right to left e.g. A; E, C, B; H, G, F, D; J, I