Jan 2026 Python OPPE 1 · Pattern and Solution Guide

Archived assessment, for preparation and review only. The screenshots are from the completed January 2026 term. Do not open this guide or use an LLM during a live graded assessment.

How to use this in the next few hours

1 · Zigzag number grid

python
Run Inline
n = int(input())
for row in range(n):
    values = range(1, n + 1) if row % 2 == 0 else range(n, 0, -1)
    print(*values)

2 · Flight tracking system

python
Run Inline
def on_time_percentage(flights):
    if not flights:
        return 0.0
    count = sum(delay < 15 for _, _, delay in flights)
    return round(100 * count / len(flights), 2)

def most_delayed_route(flights):
    delays = {}
    for origin, destination, delay in flights:
        delays.setdefault((origin, destination), []).append(delay)
    return max(delays, key=lambda route: sum(delays[route]) / len(delays[route])) if delays else None

def busiest_airport(flights):
    counts = {}
    for origin, destination, _ in flights:
        counts[origin] = counts.get(origin, 0) + 1
        counts[destination] = counts.get(destination, 0) + 1
    return min(counts, key=lambda airport: (-counts[airport], airport)) if counts else None

def total_delay_hours(flights):
    return round(sum(delay for _, _, delay in flights) / 60, 2)

def track_flights(flights):
    return {
        "on_time_percentage": on_time_percentage(flights),
        "most_delayed_route": most_delayed_route(flights),
        "busiest_airport": busiest_airport(flights),
        "total_delay_hours": total_delay_hours(flights),
    }

3 · Group and sum by key

python
Run Inline
n = int(input())
totals = {}
for _ in range(n):
    key, raw_values = input().split(":", 1)
    totals[key] = totals.get(key, 0) + sum(map(float, raw_values.split(",")))

for key in sorted(totals):
    total = totals[key]
    print(f"{key}:{total:g}")

4 · Largest zero-sum subarray

python
Run Inline
def largest_zero_sum_subarray(nums):
    first = {0: -1}
    prefix = 0
    best_start = best_length = 0
    for index, value in enumerate(nums):
        prefix += value
        if prefix in first:
            start = first[prefix] + 1
            length = index - first[prefix]
            if length > best_length:
                best_start, best_length = start, length
        else:
            first[prefix] = index
    return nums[best_start:best_start + best_length]

5 · Move even positions to the end, reversed

python
Run Inline
def move_even_indices_to_end_reversed(t):
    return t[1::2] + t[::2][::-1]

6 · Sum of ends divisible by k

python
Run Inline
def is_sum_of_ends_divisible_by_k(nums, k):
    return (nums[0] + nums[-1]) % k == 0

7 · String repeated three times

python
Run Inline
def is_repeated_thrice(s):
    if len(s) % 3 != 0:
        return False
    block_size = len(s) // 3
    block = s[:block_size]
    return s == block * 3

Final recall checklist

• Can I translate human positions to Python indices?
• Can I choose between a direct expression, slicing, a loop, and a dictionary?
• Can I state the tie-break before writing min or max?
• Can I explain why repeated prefix sums identify a zero-sum interval?
• Can I parse a line in stages and format exactly what the prompt requests?
• Did I test empty, one-element, tie, and boundary cases allowed by the contract?