Algorithms

Accept
mid = int((upperbound + lowerbound)/ 2)

Examiner’s Comments

Binary search (in both iterative and recursive form) is a standard algorithm that candidates are expected to be able to code at AS Level. Candidates made a number of common errors including not using integer division (DIV and / were accepted) for the midpoint calculation.

Some candidates returned the value being searched for at the array index rather than returning mid as the index as specified in the question.

Another common error that was made was to update mid by the wrong value, swapping the +1 and -1 round.

Max 4 if ascending and not descending

Zero marks if not provided a description and just shown data values

Examiner’s Comments

Insertion sort is one of the standard sorting algorithms that candidates need to be familiar with using. A pleasing number of candidates made a reasonable start to the

response, but fewer could produce a comprehensive response.

The question required candidates to describe and not just show how insertion sort worked, so responses that only gave diagrams showing numbers moving with no annotation did not gain credit. Some candidates mistakenly described bubble sort or merge sort.

Quite often, where candidate scored four marks, they omitted the first pass of the sort where the first item (20) is set as the sorted list. Some potentially quite good responses were too vague as to how the next item at the start of the next pass filtered back through the sorted list to its correct position.

Each purpose must be different.
Accept viable alternatives

The purpose must be relevant to the test data given.

A mark cannot be award unless both the test data and purpose are given.

Examiner’s Comments

Many candidates gained some credit for giving a valid reason for a set of test data that they presented. Clear responses included testing decimals, negatives, different data types, and testing on data

that was not already in order.

Examiner’s Comments

Most candidates demonstrated knowledge of the purpose of stacks and queues. For the similarity, a frequent response was that both stacks and queues are data structures used to store data. For the difference, most candidates identified that a stack was a LIFO structure while a queue was a FIFO structure.

AO1: Knowledge and Understanding e.g.

• Kofi’s algorithm reads data from the text file and writes these value to an array. It cannot be called by different programs, doesn’t work with different text files and does not consider the number of items in the file.
• Zac’s program also reads data from the text file and writes these values to an array. It can be called by different programs, works with different file names and does consider the number of items in the file.

AO2.1: Application e.g.
Kofi's algorithm:

• Has additional/unneces sary variables
• ...e.g. fileName, dataValue
• Loops 1000 times which is inappropriate when it needs to be used with unknown quantity
• Will not read any lines after the first 1000

Zac's algorithm:

• Uses a function so that is can be used in different programs / is independent
• Takes file name as parameter so that it can be called with different files
• The array size is 100. Therefore, if the data being read is greater than 100 the program will crash.
• Does not close the file

AO3.3: Evaluation e.g.

• Zac's is more memory efficient as it uses fewer variables
• Kofi's is more suitable in that it closes the file so it does not remain open in memory
• Zac's is more suitable to be used in different

programs due to function and not hard coding the file name

• Zac’s is easier to alter for a different file size as fewer lines of code would need to be altered

Examiner’s Comments

There were a large number of either blank or very brief responses where candidates displayed no ability to read and interpret code. The question source material was designed to help candidates to comment on a range of programming practices such as file opening and closing, conditional versus count- controlled loops and the benefits of the use of functions with parameters.

Level 1 responses often just focused on the use of two different loop types. There were few Level 3 responses that gave insightful evaluative comments. Where candidates were able to do so they often focused on memory usage or the ability to cope with different data sets that could be read.

Exemplar 2

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

Kari's Algorithm
function find_file(filename)
    file_found = false
    for i = 0 to length(files) - 1 do
        if files[i].name == filename then
            file_found = true
            return files[i]
        else
            file_found = false
        end if
    end for
    return file_found == true ? null : "file not found"
end function

Zara's Algorithm
function find_file(filename)
    array data[100]
    for i = 0 to 99 do
        if data[i] == filename then
            return data[i]
        end if
    end for
    return "file not found"
end function

The solution needs to be used in different programs. Each program will use a different list for where the number lines in the file are located.

Compare the suitability of each algorithm for the given problem.

You should consider the following in your answer:

• the suitability of the programming technique including the use of loops
• how efficiently the solution meets the requirements

A candidate's handwritten answer:

Kari's algorithm uses big O(n) time complexity. "file_found" is set to true, but the "file_found" variable is set to false in every loop. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found, the program will continue to loop and set "file_found" to false until it reaches the end of the list. This means that if the file is found,

This response showed that the candidate has thought about the issues related to the question and had carefully annotated the code when analysing it.

The response was well- structured taking each of the algorithms in turn and displayed a clear level of evaluative insight.

Examiner’s Comments

Many candidates did not identify linear but gave a description for ‘directly proportional’ or vice-versa, so only gained one mark. Candidates needed to specify that the time required increased in direct proportion to the number of items. Proportion on its own was too vague and could have meant inverse proportion

for example.

Incorrect responses included ‘quickest time to find / least operations’ defining best case rather than answering the question regarding O(n).

Examiner’s Comments

Many candidates did not identify logarithmic but tried to give a description or vice-versa. Many candidates just said the memory space increased in proportion to the log of n without explaining what this meant. For the second mark candidates had to explain that as the number of items n increased the amount of additional memory required became progressively smaller.

Examiner’s Comments

The vast majority of candidates gave the correct response of constant or O(1).

Examiner’s Comments

Half the candidates correctly identified exponential complexity, but common erroneous responses included O(n²) or O(2n) instead of O(2ⁿ).

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

Misconception

A number of candidates

erroneously thought that n² or 2ⁿ demonstrated exponential growth instead of 2ⁿ. Candidates need to have the mathematical grounding to understand the difference between different Big O growth factors.

Examiner’s Comments

Record structures were poorly understood, and it was clear that many candidates had very limited experience of using records / structures within a programming language. Many candidates gave responses related to database records rather than record data structures.

Examiner’s Comments

Some candidates gave generic properties of trees such as ‘root’ instead of specific characteristics of a binary search tree as required by the question. There was then some lack of precision when describing the number of child nodes each parent node could have (maximum two, not always two), or lack of clarity in defining ‘ordered’ without qualifying what this meant.

Examiner’s Comments

A number of candidates erroneously talked about

binary tree traversal to traverse a 1D list. However, there were many clear and correct responses. Some unqualified ‘easier’ / ‘quicker’ type responses gained no credit. Candidates had to identify that it was quicker to search/insert into the tree.

Examiner’s Comments

Many candidates achieved at least partial credit if not full credit.

The direction of left/right child nodes must be clear and cannot just be a downward vertical line.

Examiner’s Comments

The binary search tree diagram generally was answered well with the majority of candidates gaining full marks.

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.

Do not allow responses related to weighted / unweighted.

Examiner’s Comments

Most candidates struggled to score more than one or two marks for this question. Responses had to be clearly mappable to technical terms, but there was evidence of vague language in many cases. Candidates were expected to be able to talk about root nodes, cycles, hierarchy,
directed/undirected edges and
connected/disconnected nodes. Clear use of technical terms is expected at this level. A common incorrect response was

weighted/unweighted. A minimum spanning tree is a subset of a graph that can have weighted edges.

Examiner’s Comments

This question was generally well answered by many candidates. There were some vague responses such as ‘start of queue’, which was not precise enough to indicate the first item, or the index of the first item, as distinct to the indexes of the actual data structure itself.

Allow 20 and 15 in place but crossed out OR allow 20 and 15 in place only if headPointer and tailPointer are correct

Examiner’s Comments

Most candidates either tended to score full marks or no marks. Many candidates missed labelling the pointers in their diagrams and just gave updated queue values. Some candidates kept the values 20 and 15 on the diagram and correctly moved the headPointer to point to index 3 and the tailPointer to the next free space available. A considerable number of candidates erroneously shifted all items forward, showing a lack of understanding as to how a queue is efficiently implemented.

Examiner’s Comments

The first part of many responses was well attempted, with most candidates identifying the First In First Out (FIFO) property of a queue. Far fewer candidates were able to successfully expand on this for the second mark. A linked explanation was required such as a higher priority item cannot be inserted at the front/in the middle of the queue because only the first element can be accessed/dequeued. Some candidates just reiterated what FIFO meant instead of giving the linked explanation to a priority queue which was insufficient to gain the second mark.

Do not award BP3 if a value has been returned from the function for BP4 first.

Examiner’s Comments

There were many weak responses that did not outline the discrete steps required in the pop() function and there was often no reference to the topStack pointer.

A number of candidates confused a stack with a queue and talked about head/rear pointers. Some candidates confused ‘space for 100 elements’ in the question with the top of the stack and then

erroneously talked about removing item 100.

Some candidates erroneously stated that the value at topStack - 1 would be returned before saying that topStack would be decremented. The order of the steps was important for the function to operate correctly, and many candidates lost a mark due to this.

Exemplar 2

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

A candidate's handwritten answer:

Describe the steps in the function pop().

1. Check if stack is empty, if yes return an error as popping is empty.
2. get to top stack - a value and [unclear] the value and deletes it from the stack
3. move pointer at top stack to top stack - a -> top stack = top stack - a

This response shows the candidate returning the value from topStack - 1 in step 2. As soon as the function returns a value no further actions are performed within the function, so decrementing topStack in point 3 was not given.

Examiner’s Comments

The majority of candidates scored three or more marks. Some candidates erroneously used

numbers.length or

len(numbers) in the second space instead of

topStack.

True/False comparisons must be Boolean values and not strings, but allow FT after that.

If push() is called twice BP4 cannot be awarded.

Examiner’s Comments

Some candidates erroneously tried to make a call such as Function Push(15) instead of calling and using/storing the result of Push(15). A number of responses incorrectly used string values “True” / “False” instead of Boolean True / False. Many candidates tried to directly access and use the topStack pointer instead of using the function return value as required in the question.

Allow answers by example from the given dataset

Examiner’s Comments

Most candidates scored the majority of the marks available and
demonstrated a clear understanding of a linear search. Many candidates answered by example with values from the given list.

Examiner’s Comments

Most candidates correctly identified the requirement for data to be
sorted/ordered for a binary search to work.
‘Organised’ was too vague and was not accepted.

MP2 and MP5 do not have to be explicitly given in full if there is a comment to identify no change occur during the pass.

Award no marks if not an insertion sort.

Examiner’s Comments

Nearly half the candidates achieved full marks and clearly demonstrated the steps involved in an insertion sort for the given data. Some candidates confused insertion sort with either bubble, merge or selection sort, and so scored no marks for not answering the question.

Exemplar 3

[Image redrawn from the original mark scheme by an AI model (Claude Sonnet). It may contain mistakes.]

A candidate's handwritten answer:

(c) Show how an insertion sort will sort the given data into ascending alphabetical order. "rainbow" | "moon" | "sun" | "stars" | "clouds" | "tornado"

rainbow | moon, sun, stars, clouds, tornado moon, rainbow | sun, stars, clouds, tornado moon, rainbow, sun | stars, clouds, tornado [unclear] | clouds, tornado [unclear] | tornado clouds, moon, rainbow, stars, sun, tornado

• [unclear]

This exemplar
demonstrated the state of the dataset after each pass of the insertion sort. The candidate has separated the sorted and unsorted parts of the list to make the response much clearer.

Allow use of this/self or equivalent dependent on language

public procedure
new(value, level)
 this.value =
value
 this.level =

level
endprocedure

Python answers must either use comments to indicate private attributes or use the double underscore private attribute convention to be credited.
self.__level
self.level # private

Examiner’s Comments

This question either tended to be very poorly answered or very well answered. There was a clear division between candidates who were comfortable writing OOP code and class
constructors and those that were not.

Weaker candidates with little OOP experience often confused the class declaration with the instantiation method or offered no response. Many candidates often assigned the parameters to the private attribute values rather than setting the attributes to the parameters being passed in.

Where candidates gave responses in
programming languages and the intent of the response was clear, marks were given. However, sometimes Python programmers did not make it clear (by convention/comment) that class attributes were private.

Note Python self will appear, but no other parameters

def getLevel(self):

Examiner’s Comments

While there were many good responses it was also noted that a significant number of candidates erroneously tried to send a parameter to a getter() function and then return the same parameter. Some candidates did not return a value or simply tried to print the value. Other errors included writing the getter method as a function call by omitting any indication that a function was being defined.

Examiner’s Comments

Some candidates randomly picked an erroneous OOP term like polymorphism. Those candidates who could correctly identify the use of encapsulation did not always go on to specifically state that this meant access was controlled by a public getter() method.

Examiner’s Comments

Most candidates scored at least the first 2 mark- points for the grid dimensions, but far fewer could construct OOP code requiring the attribute and the relevant default parameter value to be given.

Note candidates may attempt to access private

attributes directly gameboard.grid(x,y) for example, instead of gameboard.getGridItem(x, y).

Credit cannot be given for the dependent second mark using appropriate get method if they do this, but FT marks can be awarded for later points if a reasonable attempt has been made.

Examiner’s Comments

Many candidate responses gave very little beyond the procedure declaration and taking in the x and y coordinates as inputs, thus scoring 2 marks at most. There was less successful
understanding of how to use the get() methods provided in the scenario to access the data. This is an area of the
specification that candidates require extensive practical experience of to be able to fluently answer questions like this in examination conditions.

Many candidates tried to used grid[x,y] by inserting the coordinates into the parameter values and did not identify it as an instance of an object that needed its attributes to be accessed via the appropriate getter methods. Those candidates who tried to access the attributes directly without the appropriate getter methods did achieve some further marks with

follow through marks.

Competent coders often gave responses worthy of full marks within just a few lines of code.

Exemplar 3

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

def guessGrid(board):
    [unclear]
    x = int(input("enter x"))
    y = int(input("enter y"))
    place = board.getGridItem(x, y)
    if place.getLoad() == 0:
        print("No treasure")
    else:
        print("Treasure found! [unclear] at [unclear] place.get")
        print("it is a " + place.getLoad())

This response clearly shows a logical and well- structured algorithm that uses the appropriate get() methods to access the relevant attributes of the passed parameter object. Candidates who are fluent in the use of OOP can present elegant and concise solutions.

Examiner’s Comments

Many less successful responses gave vague generalities such as ‘saves time’ or ‘more efficient’ without specifying why or how. Points given must be qualified in some way at A Level. For example, ‘saves development time as pre- written routines are available’.

Pre-written or pre-tested, and saving development time due to already being written, were the most popular answers.

Allow answers in context as long as they are clear what the features are.

Examiner’s Comments

Weaker responses were limited to one or two points for ‘calls itself’ with example such as ‘line 05’. Fewer candidates went on to identify the requirement for a base case. A variety of terminology was used for the base case such as terminating case and stopping case. If candidates were clearly referring to the case where the recursive calls stopped, and the recursion started to unwind, the mark was given.

The table is given as guidance, but actual process may be presented in different ways.

Examiner’s Comments

While many candidates continue to find recursion a challenging topic there were many who encouragingly achieved full marks. Weaker candidates traced the initial sequence of calls but found it harder to identify the last call to

recursiveAlgorithm(

• -1) that triggered the base case and then found it harder again to calculate the unwind sequence.

Note candidates can reverse the string before output if they don’t

concatenate in the order given in the example. E.g.

endResult =
str(endResult)
+ str(remainder)

The final markpoint can only be awarded where the correct output will be produced by the algorithm.

Examiner’s Comments

In general, there was a very poor standard of pseudocode algorithms from less successful responses. This demonstrated poor programming and limited problem-solving ability.

While there was no requirement to define a function the strongest candidates often did so, but then some forgot the requirement specified in the question for user input, rather than just presenting a
parameterised function in isolation.

There were several common errors that were observed. A few candidates performed the octal conversion for just two digits rather than generalising the solution for a denary number of any length. Many candidates simply used ‘/’ for division without specifying integer division through /, DIV or floor functions. Many candidates did not assign the result of a calculation to a variable for later use, presenting lines of code

such as ‘denaryNum MOD 8’ which was not given marks. The order required for appending the remainder was frequently incorrect in many of the solutions that were presented, although some candidates did reverse the string at the end of the process if they did

‘outString +=

remainder’ style solutions, which was acceptable.

Most candidates achieved at least 1 mark for taking user input, and then the majority also used either modulus to calculate the remainder or integer division to calculate the value for the next iteration. Only the strongest candidates scored 5 or 6 marks.

Exemplar 1

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

Value = Input("entry a number")
Output = ""
while Value != 0
    Output = Str(Value MOD 8) + Output
    Value = Value DIV 8
endwhile
if Output == "" then
    Output = 0
endif
Print(Output)

This candidate response is not language specific but the logic and the operations used are clear. It shows clear logical structure with appropriate indentation of logical blocks. It was given full marks.

AO1: Knowledge and Understanding Indicative content

• Big O measures the number of steps and memory usage change according to the data as the amount of data being processed increases
• Linear - grows in proportion to amount of data
• Exponential – the rate of increase is at the rate kn as n increases
• Constant - it does not change
• Logarithmic – means the rate of increase gets smaller as the amount of data increases time / time increases at a rate of logkn as n increases.

AO2: Application

• Algorithm 1 – The time taken increases as the data set grows. The space taken also significantly increases. This algorithm is not memory efficient.
• Algorithm 2 – The time increases significantly and therefore this algorithm is not time efficient. The space will never change which means the amount of memory will not change as the data set grows.
• Algorithm 3 – The time will grow less

fast as the data set grows relative to the other algorithms. The space required will also increase, but not
insurmountably. This is therefore an efficient algorithm with large data sets compared to algorithm 1 and 2 overall.

AO3: Evaluation

• Number of elements is unknown. Exponential is least appropriate because this could increase significantly and be unmanageable.
• Constant is the most ideal as the time will not increase.
• Algorithm 3 is more suitable because it has a logarithmic time complexity, so it increases less quickly than the other algorithms. It will be reasonable with a small amount (2 items) of data, but then when very large amounts (2 billion items) are needed it will not be significantly more.

Examiner’s Comments

Several candidates confused logarithmic and exponential growth rates, and a significant number of candidates thought that

exponential complexity was the polynomial function O(n²) rather than O(2ⁿ). Many candidates also defined terms such as exponential complexity as ‘where it grows
exponentially’, such circular definitions were not given marks.

Level 1 responses identified some
characteristics of Big O for constant, logarithmic, linear and exponential complexity with some occasional errors or inconsistencies.

Level 2 responses gave reasonable descriptions of both time and space complexity alongside accurate definitions for the complexity terms with an identification of algorithm 3 as being the best overall choice.

Level 3 responses had far more evaluative AO3 analysis but were few and far between. In this scenario candidates identified that it depended on the value of n, as if n was very small, exponential time growth was not an issue, so algorithm 2 might be preferential, but as n could grow to 2 billion this would be intractable, so algorithm 3 was chosen as the most practical. The data set in question had 2 billion items at most so log22,000,000,000 = 30 meant space overheads in algorithm 3 were manageable with modern storage capacities.

Exemplar 2

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

A candidate's handwritten answer:

Order is used to evaluate the complexity of an algo in respect to how its performance changes with a change to the size of input. This means be measuring how much longer it takes to complete, how much additional load is placed on components such as memory.

Linear complexity means that the time taken is [linear] to the size of the input, and will grow at a linear rate as input size increases.

Constant complexity means that no matter the size of input, the time (load) will always be the same regardless of the data being processed.

Exponential complexity grows very quickly as inf increases, whilst logarithmic increases, though at a

This response clearly demonstrates that a high scoring Level 3 response is possible within the space provided. The second page of the response shows clear AO3 evaluation between the merits of the three different algorithms and the scenario.

Allow array/list as equivalent

Examiner’s Comments

Many candidates were not precise in describing how the initial data set was repeatedly halved and did not explain how the data set was actually broken down into individual items. Very few candidates could accurately describe how the merge phase of a

merge sort combines two separate ordered lists together, and frequently this was omitted altogether. A number of candidates continued to demonstrate the misconception that data is sorted within sub-lists, rather than by the actual merging of two separate ordered lists together.

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

Misconception

Many candidates continue to think that a merge sort performs sorting of data within lists.

Merge sort performs the sorting part of the operation when it merges together two separate sub- lists that are already in a sorted order. This is done with the use of a pointer to each of the two sub-lists that acts as a placeholder. The two positions in the separate lists are compared, and the smaller item is added to the new sorted list and the pointer is incremented. The merging process then repeats until the sub-lists have been completely merged.

Examiner’s Comments

Most candidates recognised that merge sort is typically quicker than bubble sort, but there were some unqualified answers. Clear responses were phrased in terms of Big O complexities or the numbers of data items to

be sortonses were phrased in terms of Big O complexities or the numbers of

Examiner’s Comments

This question was generally well answered by most candidates with the most common answers including different types of nodes such as root, child and leaf nodes.

Some candidates used vague terminology or used terminology more commonly associated with graphs such as vertices instead of nodes, or edges instead of branches. Imprecise language such as undirected/non-directed was used whereas it would have been clearer to have indicated that trees are hierarchical structures that are rooted. Some candidates erroneously confused binary trees with general trees stating that nodes could only have a maximum of two child nodes, as the tree in this question was not specifically limited to the special case of a binary tree.

Do not allow nodes to be drawn downwards.

Examiner’s Comments

Most candidates gained some marks, with many gaining full marks. Occasionally the left/right ordering of child nodes was unclear, so marks could not be given in such instances.

Examiner’s Comments

This question was generally less successfully answered by many candidates. There was considerable vagueness in some responses such as ‘finding the end node and removing it’. This left questions such as ‘Which end node?’, ‘Removed how?’ for the examiner to infer, so were too vague to gain marks.

When candidates identified the need to locate the leaf node, most omitted the need for the parent node pointer to be set to null to break the link. Very few candidates indicated that a deleted node would then be added to a free list or that the memory freed could be retrieved via garbage collection.

Examiner’s Comments

This question was generally well answered by many candidates who appreciated that a Binary Search Tree (BST) could be efficiently searched because it is ordered, rather than traversed.

Weaker candidate often confused the search of a BST structure with traversal algorithms such as breadth first or depth first traversals.

Examiner’s Comments

Some candidates confused Depth First Search with other traversal algorithms, most commonly Breadth First Search, but this question was generally answered well by most candidates. Another common mistake was to output the nodes in the order in which they were first encountered rather than the order in which they would be visited/output.

Candidates may use an example from the tree in 1a(v) to illustrate their response.

If an answer gives implementational detail of how a stack is used, map to the bullet points given.

Examiner’s Comments

Some candidates described the term ‘backtracking’ in general, so did not answer the question, which required a response in the context of a depth first tree traversal. Many candidates thought that backtracking always began at the leftmost node, which is not true, it starts when a leaf node is reached.
However, a pleasing number of candidates did identify the first example of backtracking in the

given tree, from leaf A to parent node C.

Examiner’s Comments

While many candidates did gain full marks, a noticeable number of candidates struggled with the use of technical language in this question. Where a candidate’s intention or meaning was clear, for example, ‘headPointer is the first item’ or ‘freeListPointer is the first free space’, marks were given. Some candidates did not show an understanding that these pointers represented the start of two separate linked lists within the static array structure.

Examiner’s Comments

This question was generally well answered, with many candidates gaining marks. A generic ‘no assigned value’ was not given marks, as the response had to be answered in the context of the linked list, so end of list/not pointing to another node was required, rather than stating pointing to nothing.

Examiner’s Comments

Again, this question was generally well answered by most candidates. The most common erroneous answer was ‘Blue’ as it was the first item in Figure 3 given at index 0. This was invariably given as a response when candidates did not know what the function of the
headPointer was.

Note descriptions could be for either appending an item to the end of the current list or prepending it to the start. There are different ways to achieve this.

Allow answers that illustrate solutions by example from the table in Fig 3 at the start of the question.

Reponses must refer to the relevant pointers or give clear
exemplifications.

Examiner’s Comments

More successful responses gave good clear examples to illustrate a potential sequence of operations to describe the process, and many therefore achieved 3 or 4 marks. For example ‘new item added to location 4 indicated by

FreeListPointer and

its pointer set to Null; Existing list searched from headPointer to its end at Orange at index 3, and its pointer updated to the new last item in the list at index 4.’

Some candidates lacked appreciation that this was a static record structure in this scenario, so locations from the free list had to be used. Many candidates were unclear as to how the end of the current linked list was found, and just gave answers from that point onward without saying how it was found by traversing to the end of the existing list. There

were relatively few prepend type solutions, but they were accepted as valid where seen.

Ignore case of identifiers in pseudocode

Only penalise excessive spaces within identifier names if obvious.

Examiner’s Comments

This question required exact answers only. Many candidates gained some marks, and there was a good distribution of marks. More successful programmers tended to get most of the marks available.

Examiner’s Comments

Few candidates were able to clearly define the term 'local variable'. The concept of scope of variable s appeared to be poorly understood, with few able to define that a local variable’s scope was that of the
function/procedure in which it was declared.

Examiner’s Comments

Some candidates confused the terms local variable and global variable and gave de finitions the wrong way round. A significant number of responses demonstrated conceptual misconceptions. The contents of dataArray could be used in other parts of the program if it was passed as a

parameter to a
function/procedure, but could not be referenced directly. Responses such as giving ‘can’t be used anywhere else in the program’ as a
disadvantage were, therefore, incorrect.

Examiner’s Comments

A pleasingly high number of candidates
demonstrated a clear understanding of how a linear search operated and used clear and accurate language. More candidates were clearer in the way that they articulated the steps of the search than in previous series. However, there were still a number of candidates who gave vague responses such as ‘check each valu e until the value input is found’ that did not articulate the required steps. Some candidates gave advantages or
disadvantages of using a linear search but such responses did not answer the question.

Examiner’s Comments

Many candidates identified the fact that a linear search can operate on an unordered array whereas a binary search cannot. Some candidates alternatively cited the fact that a linear search could be used when the number of items to search was small, which was valid when qualified by the nu mber of items.

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 and have pointers enter values putting to the first at the bottom and then another putting to the at the top. of an item is popped the item at the index position of the top is deleted and the pointer's value decreases by one. if you want to enter another item you append to the list to the "position of the top then you should check if top pointer = bottom position, so stack is empty, and if (top > n) is greater than the length of the array to see if there 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

Many candidates did not appreciate that a bubble sort will require a maximum of n -1 passes in the worst case since the first item in the list will be in position after that number of passes and so would not require an additional pass. The most common incorrect responses were 356, and 3562 which confused the worst case time complexity O(n²) with the number of passes.

Accept any valid sorting algorithm
e.g. Merge sort, Quick sort

Examiner’s Comments

Nearly all candidates could identify an additional sorting algorithm with the most common response being ‘Insertion sort’.

Award a recursive algorithm as equivalent

Examiner’s Comments

Very few candidates were able to produce a working function, but many gained some marks.

Some candidates had little idea of the concept of a function and struggled to define one. Many omitted the definition statement or omitted the required parameter and then asked for user input instead.

The standard of pseudocode/code was quite weak. Indentation of constructs was often missing or hard to follow. Mid-range marks were achieved when candidates effectively utilised MOD to determine if the remainder on division by two was odd or even, and then using DIV to find the next term in the sequence.

More successful responses demonstrated an ability to problem solve, think logically, and present clear working functions.

Allow other checks for a valid number. For example

denary.isInteger ==

False

Examiner’s Comments

Candidates found Question 4 (b) easier to approach than Question 4 (a). Most could write pseudocode to accept a user input. When validating the input to be a value between 1 and 255, there was incorrect use of relational operators with off -by-one errors on occasion. There was also incorrect use of logical operators where or was used instead of and, and vice-versa. When candidates called

toBinary(inputVal),

the result was not always stored for later use.

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

Assessment for learning

When preparing candidates for the examination, they will benefit from a wide range of programming experience.

Questions such as 4 (a) and 4 (b) present an ideal opportunity for developing coded solutions to test and discuss before looking at how the algorithms could be presented as pseudocode.

Examiner’s Comments

Nearly all candidates correctly identified ‘sequence’ as the correct construct.

Examiner’s Comments

Nearly all candidates correctly identified ‘selection’ as the correct construct.

Examiner’s Comments

Most candidates correctly identified two variables from the given code.

Do not award a mark for the line number alone without correction.

Examiner’s Comments

Most candidates were given some marks, but fewer achieved full marks.

The context of the question indicated that the numbers input were positive integers, but candidates did not always appreciate this.

Candidates do not need to show each swap, so if the candidate has clearly shown the end of pass 1, they have met the first two marking points.

Marks can be awarded for correctly showing the results of each pass.

Examiner’s Comments

Most candidates clearly showed the steps that would take place in a bubble sort for the date given, with most achieving full marks. Some candidates did not

explicitly label each pass as required in the question, but marks were given where the passes could be implied.

Few candidates described the principles of a bubble sort instead of applying it to the data given.

Examiner’s Comments

Many candidates struggled to go beyond recall of definitions for calling by reference and calling by value and struggled to apply it to the code given and to provide a detailed explanation.

The bubble sort was defined as a procedure and not a function, so if numbers had been passed by value, a copy of the array would have been passed, and any changes made would not have been kept after the procedure had completed execution.

Examiner’s Comments

Most candidates could accurately define a ‘count controlled loop’ as one that repeated a predefined number of times, although some candidates gave an ambiguous response that was equally applicable to a conditional loop.

Examiner’s Comments

Many candidates found it difficult to explain the purpose of the
holdValue variable in context. Where candidates achieved some of the marks, they most

frequently identified holdValue as a temporary store that was required to prevent accidental overwriting of data during the swap process. Relatively few were able to accurately describe how the variable allowed the contents of

dataArray[x] and

dataArray[x+1] to be swapped.

Exemplar 1

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

A candidate's handwritten answer:

It acts as a temporary variable to hold value of numbers [x] while before sum is overwritten so the original value is lost and is instead copied to numbers[x+1]

This exemplar very clearly states exactly how and why the variable holdValue is required.

Examiner’s Comments

Many candidates found it challenging to apply knowledge of a bubble sort to the code given. While a pleasing number identified the need to have an outer loop, there were far fewer who were able to expand on this to explain that this was required to repeat the process for the requi red number of passes, or until no swaps had occurred during a pass.

Examiner’s Comments

Many candidates gained a mark by initialising the identifier cards, but fewer gained the second mark for correctly setting it to be a two-dimensional

structure. Many obscure forms of syntax were observed, but marks was given if it was clear that the structure was two- dimensional, however, for many responses, it was clear that a one- dimensional list had been initialised.

Examiner’s Comments

Nearly all candidates gave the correct answer line 5.

Examiner’s Comments

Most candidates knew that a recursive algorithm is self-referential and calls itself, but some candidates were too vague specifying that it ‘calls a function’. Candidates often found it harder to gain the second mark and some gave answers not related to the question such as explanations of how recursion uses stack frames during execution. Technical vocabulary is important, and some candidates did not make it clear that recursion has a base case. Those that stated a
stopping/terminating condition needed to qualify their response to say that these conditions stopped/halted the recursion. Where candidates just wrote ‘stopping condition’ it was too vague as it was unqualified since they could have been talking about any conditional loop.

Examiner’s Comments

Examiner’s Comments

Those candidates who scored full marks in 7b had little difficulty giving the correct call
calculate(10). Some candidates just wrote 10, which did not answer the question. Those who showed little
understanding of recursion in 7b rarely gave the correct answer in 7c.

Examiner’s Comments

Most candidates correctly identified the root node as 2005.

Examiner’s Comments

Most candidates correctly identified valid leaf nodes, but a significant number erroneously gave 1920 and 2350 as the child nodes of the root instead of identifying leaf nodes.

Examiner’s Comments

Many candidates scored at least 2 marks, but many erroneously inserted 2600 before 2780, or just put 2600 as the left child node of 2560. A common mistake was to use straight lines for new child

nodes rather than clearly indicating whether the new child node was a left/right child of the parent node.

AO1: Knowledge and Understanding Indicative content

• Breadth first takes first value then visits all nodes connected to it. It then takes all nodes connected to those nodes.
• Depth first goes to the left node, this becomes a new tree. It continues going to the left until a leaf. It then returns this, then goes right and repeats from the start. Follow left, follow right, take root.

AO2: Application

• Breadth will return 2005 1920 2350 1500 1985 2100 2560 (1420) 1952 2000 (2050) (2780) (2600)
• Post-order / Depth will return (1420) 1500 1952 2000 1985 1920 (2050) 2100 (2600) (2780) 2560 2350 2005

AO3: Evaluation Evaluations may vary and include one or more of the following points:

• Breadth is more efficient when the data searched for is closer to the root.

• Depth is more efficient when data to be search for is further down.

• Depth memory requirement is linear

• Depth can be written recursively to aid understanding.

• Breadth in general is better time complexity

• In large trees depth may never return a value

Candidates are not expected to know the complexities for the search traversals, however credit should be awarded if candidates choose to include these.

Limit to band 2 if there is no evaluation of BFS/DFS

Examiner’s Comments

Many candidates achieved some marks, but a few did confuse Breadth-first search (BFS) and Depth- first search (DFS), getting them the wrong way round.

Most had a much clearer understanding of BFS than DFS and were able to score marks in Level 1 for showing how a BFS would be carried out. Fewer managed to accurately show how a DFS would work. While there was an understanding that DFS would traverse leftward to the lowest leftmost node, descriptions of back tracking were not given as many marks. A common

mistake made with DFS was to output the nodes in the order they were first visited rather than the order in which they are output.

Few could describe the mechanics of the algorithms with BFS using a queue and DFS using a stack. Those who did achieved the top of Level 2.

Very few candidates could give exemplar uses of BFS or DFS (e.g. deleting nodes in a tree) or compare cases where they might be used (e.g. distance of target node(s) from root), with very little evaluation. This meant there were very few Level 3 responses seen.

Note if numberArray - 1 / 49 used, then for loop for y will need to be 0 to arrayLength - 1

Allow other suitable valid identifier in place of tempValue e.g. temp

Examiner’s Comments

Many candidates scored at least 1 mark for correctly initialising the arrayLength, although some erroneous

length.arrayLength

rather than

arrayLength.length

answers were seen. If candidates are assuming the existence of inbuilt methods they should reference them in the correct OOP way.

Very few candidates achieved the second marking point for the loop. A very common off-by-one error was seen with the value 1 given. If arrayLength was set to 50 this would cause a run time error for an out-of- bounds reference when the loop ran.

Some candidates tried to swap the array values directly in a Pythonic style that was not suitable for a pseudocode solution in context, and some used incorrectly formatted variable identifiers.

Variable identifiers Valid identifiers must be single words. In a number of instances, it was clear that tempValue was given as temp Value. Where candidates give an answer that clearly has spaces within an intended identifier name no marks will be given.

Do not award a mark for the final stage, unless candidate has shown the previous sorting stage(s).

Examiner’s Comments

Many candidates presented very clear solutions that used the values in numberArray to construct clearly annotated diagrams. Textual prose responses tended to either not refer at all to the given data set, or mentioned it only partially, so lost marks. There was occasional confusion with other

sorting algorithms, but this was seen relatively infrequently,

Where errors were made candidates did not split the data to the atomised level. Many did not fully understand how a merge sort works by merging two separate lists of ordered values together but performed in-place sorts in sub-lists.

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

Misconception

The merge phase in a merge sort takes two separate lists that are already ordered. Values in those two separate lists are taken and merged in sequence to form a new list. E.g. List 1 [1, 9] and List 2 [2, 10] are taken and merged 1 from List 1, 2 from List 2, 9 from List 1 and then 10 from List 2, into a new List.

Values in lists [1, 9] and [2, 10] are not placed in a list [1, 9, 2, 10] and then sorted in-situ. A significant number of candidates thought that a merge sort split lists up until values were in pairs and showed [15, 7] going directly to [7, 15] (i.e. an in-situ sort) without first being atomised into two separate lists of [15] and [7] and then being merged to give [7, 15].

Exemplar 2

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

The image shows a handwritten diagram titled "Exemplar 2" illustrating a process of splitting and merging sets of numbers.

At the top, there are three rows of numbers in boxes:

1. [2] [12] [1] [9] and [3] [5] [15] [7]
2. [2] [12] and [1] [9] and [3] [5] and [15] [7]
3. [2] [12] [1] [9] and [3] [5] [15] [7] (with arrows pointing from the second row to these boxes)

Below these, there is a section labeled "splitting:" showing the numbers grouped: 2, 12 and 1, 9 and 3, 5 and 7, 15

Below that, there is a section labeled "merging:" showing the groups being combined: 1, 2, 9, 12 and 3, 5, 7, 15

At the very bottom, the final merged set is shown: 1, 2, 3, 5, 7, 9, 10, 15 (Note: the '10' appears to be a handwritten addition or correction in the final line).

Candidate responses to questions that require ‘showing’ how data sets are ordered by sorting algorithms are best tackled by using clearly annotated diagrams such as this exemplar response.

AO1: Knowledge and Understanding Indicative content

• Merge sort splits data into individual lists and merges
• Insertion makes first value sorted list, then inserts each item into the sorted list
• Bubble sort looks through each item in turn, number of items times

AO2: Application

• Merge uses more memory as new lists are needed. Insertion and Bubble need constant memory.

• Bubble and Insertion have the best best-times, both O(n) because they run through the data once. merge sort requires a minimum number of stages so best case is longer (O(n log(n))

• Merge average is the same as best. Insertion and Bubble has average o(n^2).

• Worst time merge has same has best and average because same number of stages are needed. Bubble sort and insertion all have worse O(n^2)

AO3: Evaluation

• There are a small number of elements (10) therefore a bubble sort of insertion would be better space wise because no further space is needed.
• Merge would not need excessive amounts of more memory as there are only a small number of elements.
• Time complexity, there is a small number of elements therefore Bubble and Insertion may be preferable. Differences are unlikely to be significant, so either would be more appropriate.

Examiner’s Comments

Most candidates could describe the basic elements of each of the bubble, merge and insertion sort, although some had difficulty remembering insertion sort and confused it with quick sort.

Many candidates

struggled to show accurate knowledge of the Big O time complexity values for
best/average/worst case for the three algorithms, which is a learnt response. Some did give very good examples of where bubble and insertion sort would give best/worst case times.

Very few candidates could cite space complexity, and where they did a number thought bubble/insertion were space complexity O(n) because there are n elements rather than O(1) which means constant with no extra memory overhead.

There was some evaluation of the number of items being sorted in most cases.

Overall, many responses were clustered in Level 2, but a pleasing number of candidates achieved Level 3 with clear and detailed descriptions, accurate Big O values, and an evaluation of the size of the data set being sorted.

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.

Must contain a similarity and a difference for both marks.

Examiner’s Comments

Those candidates who scored well in c(i) frequently gained full marks for describing the similarities and differences between Dijkstra’s algorithm and the A* algorithm. The most common responses were that both give the shortest path and that A* uses heuristics.

Examiner’s Comments

Most candidates successfully identified that data must be ordered as a precondition for a binary search. A few candidates were too vague giving unqualified answers such as ‘must be sorted’, without specifying what had to be sorted.

Not all mark points are dependent, but points awarded must following logically in sequence.

Examiner’s Comments

Many candidates scored some marks for describing the steps involved in a linear search, but relatively few presented a comprehensive and detailed description for full marks. Many responses used vague language such ‘checking if the value is found’ without explaining that a comparison between the current term and the target search value must be performed. Other examples of vague

language use included responses such as ‘keep going until you find what you’re looking for’, which begged the question, how do you know when you’ve found what you’re looking for?

Common errors included candidates who mistakenly described a binary search, and those who did not answer the question. Examples of not answering the question included giving properties of a linear search such as its linear run time or the fact that it can be run on an unordered data set.

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(i):
    length = length(approximations.length())
    maxValue = -1
    index = 0
    found = False
    while found == False and index < length:
        if approximations[index] > maxValue then
            maxValue = approximations[index]
            found = True
        else
            index = index + 1
    endwhile
    return
    return maxValue
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 -1

[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.

Allow line 4 and 12

Examiner’s Comments Most candidates had little difficulty identifying line 05 as the obvious response, but some candidates did choose the decision taking place at the end of the do..until loop in line 12.

Examiner’s Comments Nearly all candidates correctly identified numbers as the correct parameter name.

Examiner’s Comments Candidates found it difficult to articulate a response that broke the purpose of the temp

variable down in lines 06 to 08 into logical steps with reasons. Many candidates identified it as a temporary store, but few could explain that it allowed the contents of the two array positions to be swapped without erroneously overwriting either value.

Examiner’s Comments Many responses to this question were generalised answers that stated that the sorted variable determined whether the data was sorted or not. This could be an indication that candidates did not have practical experience of implementing a bubble sort with a swap flag. Most candidates did not appreciate the function of the variable during each pass of the bubble sort. Candidates need to be well versed in the different ways of implementing a bubble sort.

Accept

for i = 0 to row.length-1

for i = 0 to row.length

for i=0 to 5

Accept

for i = 0 to row.length-1

for i = 0 to row.length

for i=0 to 5

Do not award marks for line numbers alone without stating the error.

Consider 1 mark for not changing line 04 but changing 05 to true and 09 to False

AO1: Knowledge and Understanding Indicative content Local variables:

• Scope within the module defined within
• Cannot access externally unless passed as

parameter, or returned from function

• When module is exited, memory of variable is freed

Global variables:

• Scope within the entire program
• Can access from anywhere
• Retained in memory permanently

ByRef Points to location of variable
ByVal Sends the value

AO2: Application

• If global the arrays can be accessed from all modules by direct reference
• If local to the main, the arrays will need to be passed as parameters byreference
• Can send ByVal – but not always possible with arrays in some languages
• Modules are self contained and then can be reused in other programs he wants to create without needing to take the global variables with them

AO3: Evaluation e.g.

• +ve Local = memory efficient
• +ve Global = easier programming,

simpler to follow, easier to debug

• -ve Global = memory inefficient, not good programming technique
• -ve Local = more difficult to trace/debug/follow where the values are passed
• Relatively small program – don’t know about overall plan for it, it might not be memory intensive, unlikely anyone else is going to access/amend e.g. use as a library – therefore global would not waste significant resources

Accept other specific language conventions that would correctly achieve the same outcomes.