(a)
For the correct answer (any one method + correct description):

addItem() — adds an element to the collection (at the end)
getNext() — returns / gets / obtains the next element from the collection (indicated by the pointer)
resetNext() — restarts the iteration from the first element / moves the pointer back to the beginning
hasNext() — returns TRUE if there is at least one more element in the collection that has not been accessed in the current iteration
isEmpty() — returns TRUE if the collection contains no elements

Take hasNext() as a worked example of a collection method. A collection uses an internal pointer to track which element it is currently “at”. The hasNext() method peeks ahead from the current pointer position and returns TRUE if there is still at least one element that has not yet been retrieved in this pass through the collection, or FALSE if the pointer has reached the end. This is extremely useful as a loop condition — you simply keep calling getNext() as long as hasNext() returns TRUE, and the loop terminates naturally when all elements have been visited.

(b)
For the correct answer:
Correct use of collection methods hasNext(), getNext(), resetNext() or equivalent; initialising starting array index as $0$; appropriate loop for accessing RAINBOW elements; correct assignment to both arrays using same index with two adjacent elements from RAINBOW.

Example pseudocode:

RAINBOW.resetNext()
I = 0
loop while RAINBOW.hasNext()
    COLOUR[I] = RAINBOW.getNext()
    ORDER[I] = RAINBOW.getNext()
    I = I + 1
end loop

The RAINBOW collection alternates between a colour name and its order letter on every pair of elements. So the algorithm must call getNext() twice per loop iteration — once to get the colour (stored in COLOUR[I]) and immediately again to get the matching order letter (stored in ORDER[I] at the same index). Resetting the pointer at the start ensures we begin from the very first element. The index I starts at 0 and increments after each pair, so the corresponding colour and its order indicator always land at the same array index, preserving the parallel relationship between the two arrays.

(c)
For the correct answer (bubble sort or selection sort):
Nested loops with correct conditions; use of flag to stop the loop if no swaps made (bubble sort) or setting of MIN before inner loop (selection sort); comparing adjacent (bubble) or comparing to find smallest (selection) elements of ORDER array; swapping contents in ORDER array if required; corresponding swapping of contents in COLOUR array.

Bubble sort example:

SWAP = TRUE
loop while SWAP = TRUE
    SWAP = FALSE
    loop I from 0 to 5
        if ORDER[I] > ORDER[I + 1] then
            TEMP1 = ORDER[I]
            TEMP2 = COLOUR[I]
            ORDER[I] = ORDER[I + 1]
            COLOUR[I] = COLOUR[I + 1]
            ORDER[I + 1] = TEMP1
            COLOUR[I + 1] = TEMP2
            SWAP = TRUE
        end if
    end loop
end loop

Selection sort example:

loop I from 0 to 5
    MIN = I
    loop J from I + 1 to 6
        if ORDER[J] < ORDER[MIN] then
            MIN = J
        end if
    end loop
    if MIN <> I then
        TEMP1 = ORDER[MIN]
        TEMP2 = COLOUR[MIN]
        ORDER[MIN] = ORDER[I]
        COLOUR[MIN] = COLOUR[I]
        ORDER[I] = TEMP1
        COLOUR[I] = TEMP2
    end if
end loop

The critical detail in this question is that any swap applied to the ORDER array must also be applied to the COLOUR array at the same time. Because ORDER and COLOUR are parallel arrays (their meaningful relationship is that ORDER[I] always corresponds to COLOUR[I]), swapping only ORDER would break that relationship — Indigo might end up paired with the wrong order letter. So every time two ORDER elements are swapped, the COLOUR elements at those same indices must be swapped identically. This requires two temporary variables (TEMP1 for ORDER, TEMP2 for COLOUR) during every swap operation.

(d)
For the correct answer (at least one similarity AND one difference):

Similarities:
Both use nested loops, each time reducing the inner loop; both have the same worst-case time complexity $O(n^2)$; both perform in-place sorting directly within the array without requiring additional data structures or memory.

Differences:
Bubble sort works by comparing adjacent elements and swapping them if they are in the wrong order, repeating until the array is fully sorted; Selection sort works by finding the smallest (or largest) element from the unsorted portion and swapping it into position; Bubble sort can exit early / is faster if the list is already sorted (best case $O(n)$); Selection sort must complete the full procedure for the entire list every time (best case $O(n^2)$); Bubble sort has a higher number of comparisons and swaps for larger datasets, making it generally slower in practice.

Think of bubble sort as a very patient process that keeps walking through the list, nudging out-of-order neighbours past each other — like bubbles rising to the surface — until nothing needs to move any more. Selection sort is more strategic: on each pass it hunts through the entire remaining unsorted section to find the minimum element, then plants it at the front of the unsorted section in a single swap. Both are $O(n^2)$ in the worst case, but bubble sort has the nice property that if the list happens to already be sorted, it detects this in just one pass and exits (effectively $O(n)$ in the best case), whereas selection sort will methodically scan everything regardless.