A process for solving problems

An algorithm is a precise, step-by-step method for solving a problem. You already write algorithms every time you write a function: "loop over the prices, add each one to a running total, return the total" is an algorithm.

The hard part of a new task is rarely the Python syntax. It is deciding what the steps should be. Imagine your manager at Sahra Logistics asks: "Which hour of the day had the most deliveries yesterday?" If you start typing straight away you will probably write something that works for the first example you think of and breaks on the second. This lesson gives you a process that experienced programmers follow, often without noticing:

1. Understand — restate the problem. What goes in? What comes out? What are the rules?
2. Examples — work out a few inputs and their correct outputs by hand, including awkward ones.
3. Decompose — split the task into smaller steps you already know how to do.
4. Plan — write the steps as pseudocode: plain-language instructions shaped like code.
5. Implement — translate the plan into Python.
6. Test — run your examples. Every mismatch teaches you something.
7. Reflect — could it be clearer? Faster? What would break it?

Step 1 and 2: understand, then make examples

Restating the delivery question precisely forces decisions. Input: a list of delivery times as "HH:MM" strings. Output: the hour (an integer 0–23) with the most deliveries. Rules you have to choose: what if two hours tie? What if the list is empty?

Examples settle those choices before any code exists:

The last three rows are edge cases: inputs at the boundary of what the function must handle. Empty input, a single item, ties and duplicates are the usual suspects.

Step 3 and 4: decompose and plan

The task splits into two smaller ones you know from earlier tracks: count deliveries per hour (a dictionary of counts) and find the hour with the largest count (a loop that remembers the best so far). Written as pseudocode:

if there are no times: answer None
counts = empty mapping from hour to count
for each time:
    hour = the number before the colon, as an integer
    add 1 to counts[hour]
best = None
for each hour from smallest to largest:
    if best is None or counts[hour] > counts[best]:
        best = hour
answer best

Pseudocode has no strict syntax. Its job is to let you check the logic — "does looping from the smallest hour give the earlier hour on a tie?" — before Python details get in the way. (It does, because > only replaces the best on a strictly larger count.)

def busiest_hour(times):
    if not times:
        return None
    counts = {}
    for t in times:
        hour = int(t.split(":")[0])
        counts[hour] = counts.get(hour, 0) + 1
    best = None
    for hour in sorted(counts):
        if best is None or counts[hour] > counts[best]:
            best = hour
    return best


examples = [
    (["09:15", "09:40", "14:05"], 9),
    (["14:05", "09:15", "14:30", "09:40"], 9),
    (["23:59"], 23),
    ([], None),
]
for times, expected in examples:
    actual = busiest_hour(times)
    status = "ok" if actual == expected else "MISMATCH"
    print(status, times, "->", actual)

The table of examples became a tiny test loop. Each row is checked automatically and anything unexpected says MISMATCH. In the Testing track you would write these as assert statements or pytest tests; the idea is the same.

Reflect. The function makes one pass over the times and one pass over at most 24 hours, so it stays fast even for a million deliveries. Could it be clearer? Perhaps collections.Counter would shorten the counting step. Reflection is where you notice such options — after you have something correct.

def busiest_hour(times):
    counts = {}
    for t in times:
        hour = int(t.split(":")[0])
        counts[hour] = counts.get(hour, 0) + 1
    best = None
    for hour in counts:
        if best is None or counts[hour] > counts[best]:
            best = hour
    return best

print(busiest_hour(["14:05", "09:15", "14:30", "09:40"]))
print(busiest_hour(["09:15", "14:05", "14:30", "09:40"]))

base = total divided by months, rounded down
extra = the remainder of total divided by months
result = empty list
repeat months times, counting i from 0:
    if i is less than extra: add base + 1
    otherwise: add base
return result