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) — and the good news is that the algorithm's overall structure never changes. What changes is exactly one thing: every comparison that previously read a bare array element, such as array[i], now reads one specific named field of a record instead, such as records[i].stock. The loop, the running variables, and the logic are all identical to SDD13/14 — only what's being compared is different.

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 (comparing records[i].stock) or the record with the highest price (comparing records[i].price). Critically, what's usually wanted here isn't the smallest number in isolation, but which item has it — so these algorithms typically track the index of the current best record, not just the field value itself, so the whole matching record can still be retrieved afterwards.

Count-occurrences as a condition, not just equality

SDD14's count-occurrences checked for an exact match (array[i] == 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 exactly which single line of an already-known, already-tested algorithm needs to change to make it work on a new data structure, rather than treating records as requiring a completely new algorithm to be designed from scratch. 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 — recognising a standard pattern and adapting it, rather than reinventing logic that already exists and is already known to work correctly.

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 i in range(1, len(records)):
        if records[i].stock < records[smallestIndex].stock:
            smallestIndex = i
    return smallestIndex

minIndex = findMinStockRecord(itemRecords)

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

maxIndex = findMaxPriceRecord(itemRecords)

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

result = countLowStock(itemRecords, 20)

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

Task Set A — Core questions

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

Task Set B — Extension