Array Traversal Patterns: Min, Max, Count

Array Traversal Patterns: Min, Max, Count

Where these patterns fit at N5

The SQA N5 specification names exactly three standard algorithms: input validation, a running total within a loop, and traversing a one-dimensional array. Finding a minimum, finding a maximum, and counting values are not separately named standard algorithms. They are useful application patterns built from array traversal, a variable initialised before the loop, and a comparison or update inside the loop.

All three algorithms in this lesson share the same underlying structure: set up a variable before the loop, traverse the array element by element, update the variable inside the loop based on a condition, and use the result after the loop ends.

Find minimum

The find-minimum algorithm locates the smallest value in an array. The key steps are:

1. Initialise a variable called minimum to the value of the first element of the array: minimum = array[0].
2. Loop from index 1 to the last index (you have already accounted for index 0).
3. Compare each element to minimum. If the element is smaller, update minimum to that element's value.
4. After the loop, minimum holds the smallest value in the array.

temps = [18, 12, 25, 9, 21, 14]
minimum = temps[0]          # initialise to first element (18)
for index in range(1, len(temps)):
    if temps[index] < minimum:
        minimum = temps[index]
print("Minimum:", minimum)

Trace: minimum starts at 18. index=1: 12<18 → minimum=12. index=2: 25<12? No. index=3: 9<12 → minimum=9. index=4: 21<9? No. index=5: 14<9? No. Output: Minimum: 9.

Find maximum

The find-maximum algorithm is structurally identical to find-minimum — only the comparison operator changes. Instead of checking if the current element is smaller than the running minimum, check if it is larger than the running maximum:

scores = [45, 78, 62, 91, 30, 55]
maximum = scores[0]          # initialise to first element (45)
for index in range(1, len(scores)):
    if scores[index] > maximum:
        maximum = scores[index]
print("Maximum:", maximum)

Trace: maximum starts at 45. index=1: 78>45 → maximum=78. index=2: 62>78? No. index=3: 91>78 → maximum=91. index=4: 30>91? No. index=5: 55>91? No. Output: Maximum: 91.

The only difference from find-minimum is > instead of < in the if condition.

Count occurrences

The count algorithm counts how many elements in an array satisfy a given condition — for example, how many scores are above 50, or how many temperatures are below zero. The steps are:

1. Initialise a counter variable to 0: count = 0.
2. Loop from index 0 to the last index (the full array, not starting at 1).
3. Check the condition for each element. If it is True, add 1 to the counter: count = count + 1.
4. After the loop, count holds the number of elements that met the condition.

ages = [16, 14, 17, 15, 16, 18, 16, 13]
count = 0
for index in range(len(ages)):
    if ages[index] == 16:
        count = count + 1
print("Count:", count)

Trace: 16==16 → count=1. 14==16? No. 17==16? No. 15==16? No. 16==16 → count=2. 18==16? No. 16==16 → count=3. 13==16? No. Output: Count: 3.

The condition can use any comparison operator: ==, >, <, >=, <=, or !=. For example, counting all values greater than 50 uses if ages[index] > 50.

SQA pseudocode for the three algorithms

In the exam, questions may ask you to write pseudocode rather than Python. The structure maps across directly, with SET … TO replacing assignment, IF … THEN … END IF replacing if, and FOR index FROM … TO … DO … END FOR replacing for … in range(…).

Note that find-minimum and find-maximum loop from index 1 (since the initial value is already set to index 0), while the count algorithm loops from index 0 (because the counter starts at 0, not at the first element's value).