def rectangle_area(width, height):
    """Return area for suitable non-negative numeric dimensions."""
    return width * height

area = rectangle_area(4, 3)
print("Area:", area)
print("Double area:", area * 2)
print("Zero-width area:", rectangle_area(0, 3))

The helper returns a reusable number. The caller decides what to calculate and display next. The stated dimension assumptions are not enforced by the multiplication itself.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def double(number):
    return number * 2

result = double(6)
print("Result:", result)
print("With one more:", result + 1)

The repaired call evaluates to the doubled number. The original body printed a message and reached its end, so its implicit result was None. Adding one to that result would raise TypeError.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def score_report(name, score, maximum=10):
    """Format suitable scores with a positive maximum."""
    percentage = score / maximum * 100
    return f"{name}: {score}/{maximum} ({percentage:.1f}%)"

print(score_report("Maya", 8))
print(score_report(score=15, maximum=20, name="Kai"))

The call binds arguments to parameters and the helper returns text. A zero maximum breaks the stated precondition; the example does not claim division performs validation.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def add_note(note, notes=None):
    if notes is None:
        notes = []
    notes.append(note)
    return notes

print(add_note("first"))
print(add_note("second"))
shared = []
returned = add_note("kept", shared)
print("Caller list:", shared)
print("Same object:", returned is shared)

The default None is immutable and signals omitted input. Each omitted call creates a fresh list; a supplied list is intentionally mutated. The contract should state that effect.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

# SAVE THIS BLOCK AS pricing.py
def ticket_total(quantity, unit_price):
    return quantity * unit_price

# SAVE THE FOLLOWING BLOCK AS app.py
import pricing

def main():
    print("Cost:", pricing.ticket_total(3, 4.5))

if __name__ == "__main__":
    main()

The application depends on the helper module. The helper needs values through parameters rather than importing application state. The two labelled blocks are two files, not one runnable combined solution.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def attendance_percentage(attended, possible):
    return attended / possible * 100

def attendance_report(name, attended, possible):
    value = attendance_percentage(attended, possible)
    return f"{name}: {value:.1f}% attendance"

print(attendance_report("Maya", 8, 10))
print(attendance_report("Kai", 0, 10))

Responsibilities are separate: one calculates, one formats. Refactoring should preserve the report’s agreed behaviour. The zero-denominator case is a stated limitation rather than a silently accepted result.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def linear_search(values, target):
    for index, value in enumerate(values):
        if value == target:
            return index
    return None

position = linear_search([8, 5, 12, 5], 8)
if position is not None:
    print("Found at:", position)
else:
    print("Absent")

Index zero is a real match but falsey, so a truthiness check is unsuitable. The absent result follows exhaustion; a matching return ends the call early.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def binary_search(values, target):
    low, high = 0, len(values) - 1
    while low <= high:
        mid = (low + high) // 2
        if values[mid] == target:
            return mid
        if target < values[mid]:
            high = mid - 1
        else:
            low = mid + 1
    return None

print(binary_search([2, 5, 8, 12, 16], 12))
print(binary_search([], 12))

The bound changes depend on ascending order. This implementation finds any duplicate match, so comparing its index blindly against a first-match linear search would test the wrong contract.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def ranking_key(player):
    return -player["score"], player["name"]

players = [{"name": "Noor", "score": 8},
           {"name": "Kai", "score": 12},
           {"name": "Maya", "score": 8}]
ranked = sorted(players, key=ranking_key)
print("Arrival:", [player["name"] for player in players])
print("Display:", [player["name"] for player in ranked])

The tuple explicitly defines two ordering levels. This is a different tie policy from sorting solely by score stably or sorting whole (score, name) tuples in reverse. A new outer list still shares the record dictionaries.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def factorial(number):
    if type(number) is not int or number < 0:
        raise ValueError("Use a non-negative integer")
    if number == 0:
        return 1
    return number * factorial(number - 1)

def factorial_iterative(number):
    if type(number) is not int or number < 0:
        raise ValueError("Use a non-negative integer")
    total = 1
    for value in range(1, number + 1):
        total *= value
    return total

for number in range(7):
    assert factorial(number) == factorial_iterative(number)
print("Factorial checks passed")

The recursive version uses a base case and progress step. Agreement provides evidence but does not replace understanding. The loop avoids a growing call stack; integer sizes still grow with the result.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

from world import new_world
from engine import move, take_item, has_won

world = new_world()
state = {"room": "hall", "inventory": []}
move(world, state, "north")
assert state["room"] == "hall"
move(world, state, "east")
assert take_item(world, state, "key") == "Taken: key"
assert take_item(world, state, "key") == "That item is not here."
assert state["inventory"] == ["key"]
move(world, state, "west")
move(world, state, "north")
assert has_won(state)
assert new_world()["lab"]["items"] == ["key"]
print("Adventure checks passed")

The checks inspect state and effects separately from interface text. The reusable modules permit direct action testing without scripted input. They assume trusted, correctly authored room records.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.

def search_checks(values, target):
    checks = 0
    for value in values:
        checks += 1
        if value == target:
            return True, checks
    return False, checks

values = list(range(10))
print("First:", search_checks(values, 0))
print("Absent:", search_checks(values, 99))
visits = 0
for item in values:
    for repeat in range(3):
        visits += 1
print("Nested visits:", visits)

The selected operations expose growth without claiming every machine operation was counted. The handover demonstrates whether decomposition communicates responsibilities to another programmer.

A different implementation can also be correct if it meets the requirements and tests. Compare meaning and behaviour, rather than only copying the source.