Key vocabulary

The same four algorithms, one field at a time

What changes, and what doesn't

SDD13 and SDD14 built linear search, minimum, maximum, and count-occurrences against plain 1D arrays of bare values. This lesson re-runs all four algorithms against the tuck shop's itemRecords array of Item @dataclass records (SDD6–12). All four keep the same overall algorithmic shape: traverse the array, test the relevant data, update running state, and return a result. The exact adaptation is not identical for every algorithm, however. Linear search and conditional count mainly change the tested expression from a bare value such as array[position] to a named field such as records[position].stock. Minimum and maximum also need coordinated changes to their running state when the result must identify a whole record.

Linear search on a record field

Rather than searching an array of plain names for a match, linear search on records compares one field — typically .name — of each record to the target, e.g. records[index].name == target. The rest of the algorithm (the found flag, the incrementing index, the -1 sentinel for "not found") is completely unchanged from SDD13.

Minimum and maximum on a record field

Instead of comparing bare numbers, the minimum/maximum algorithms now compare a chosen numeric field of each record — for example, finding the record with the lowest stock or the record with the highest price. SDD14 safely initialised a running value from the first element, such as smallest = array[0], then compared the remaining elements from index 1. Here the equivalent safe initialisation is smallestIndex = 0: the first record is the current best record. The comparison must read through that index, for example records[position].stock < records[smallestIndex].stock; a better record makes the update store position in smallestIndex; and the function returns that index. These coordinated initialisation, comparison, update, and return changes are necessary because the whole matching record must remain retrievable, not just its field value.

Count-occurrences as a condition, not just equality

SDD14's count-occurrences checked for an exact match (array[position] == target). Applied to records, this same "running counter, check every element" shape works equally well for a condition rather than strict equality — for example, counting how many items have stock < 20 (a reorder-warning count), simply by swapping == for < in the comparison. The algorithm's shape is unchanged; only the comparison operator and what's being compared (a field, not a bare value) are different.

Why this lesson matters beyond just "more practice"

It would be easy to treat this lesson as simply repeating SDD13/14 with slightly different data, but the real point is narrower and more useful than that: recognising which parts of an already-known, already-tested pattern can stay and which must change for a new data structure. Sometimes the adaptation is chiefly one tested expression, as in linear search and conditional count. Sometimes several connected lines must change together, as in an index-tracking minimum or maximum. This is precisely the kind of transferable skill the SQA assignment (Task 1, SDD7–SDD12's parameter passing and file handling combined with SDD13–15's algorithms) rewards — adapting a standard pattern accurately rather than reinventing it or changing only part of the required state.

Worked examples

def linearSearchRecords(records, target):
    index = 0
    found = False
    while index < len(records) and not found:
        if records[index].name == target:
            found = True
        else:
            index = index + 1
    if found:
        return index
    else:
        return -1

result = linearSearchRecords(itemRecords, "Flapjack")

def findMinStockRecord(records):
    smallestIndex = 0
    for position in range(1, len(records)):
        if records[position].stock < records[smallestIndex].stock:
            smallestIndex = position
    return smallestIndex

minIndex = findMinStockRecord(itemRecords)

def findMaxPriceRecord(records):
    largestIndex = 0
    for position in range(1, len(records)):
        if records[position].price > records[largestIndex].price:
            largestIndex = position
    return largestIndex

maxIndex = findMaxPriceRecord(itemRecords)

def countLowStock(records, threshold):
    count = 0
    for position in range(len(records)):
        if records[position].stock < threshold:
            count = count + 1
    return count

result = countLowStock(itemRecords, 20)

def findMaxStockRecord(records):
    largestIndex = 0
    for position in range(1, len(records)):
        if records[position].stock > records[largestIndex].stock:
            largestIndex = position
    return largestIndex

Task Set A — Core questions

def countLowStock(records, threshold):
    count = 0
    for position in range(len(records)):
        if records[position].stock < threshold:
            count = count + 1
    return count

Task Set B — Extension