Python Tricks for Competitive Programming: The Neo Way

The Quest Begins (The "Why")

I still remember the first time I walked into a Codeforces round feeling like I was about to face the final boss in Dark Souls — my heart was pounding, my fingers were poised over the keyboard, and I kept getting stuck on the same stupid problem: “Given an array, find the maximum sub‑array sum for every prefix.” I kept writing nested loops, resetting sums, and watching my runtime creep from O(n²) to O(n³) as the constraints grew. After yet another frustrating TLE (Time Limit Exceeded), I muttered to myself, “There has to be a cleaner way.” That moment was the spark that sent me down a rabbit hole of Python’s lesser‑known gems — features that, once you see them, feel like unlocking a secret cheat code.

The Revelation (The Insight)

During that late‑night debugging session, I stumbled upon three tricks that most competitive programmers either overlook or relegate to “nice‑to‑have” status. They aren’t flashy, but they shave off precious milliseconds and, more importantly, make your intent crystal clear.

1. The Walrus Operator (:=) – Introduced in Python 3.8, it lets you assign and use a value in the same expression.
2. itertools.accumulate – A tiny powerhouse that can compute prefix sums, prefix xors, running minima, or any cumulative operation you can dream of.
3. collections.deque for O(1) Sliding Windows – When you need to add at one end and remove from the other (think queues or sliding‑window maxima/minima), a deque outperforms a list by orders of magnitude.

Each of these solves a specific “gotcha” that trips up even seasoned devs: the walrus operator’s subtle precedence rules, accumulate’s default behavior, and deque’s method names that look alien at first glance. Let’s see them in action.

Wielding the Power (Code & Examples)

1. Walrus Operator – Inline Assignment in Loops & Comprehensions

The Struggle

Suppose we need to read lines from stdin until we hit an empty line, processing each non‑empty line on the fly. The classic way looks like this:

import sys

results = []
for line in sys.stdin:
    line = line.strip()
    if not line:
        break
    results.append(process(line))

It works, but we repeat line = line.strip() and the if not line: break pattern everywhere.

The Gotcha

The walrus operator can combine the assignment and the test, but you must parenthesize it correctly when it’s inside a comprehension; otherwise Python thinks you’re trying to assign to a tuple.

The Victory

import sys

results = []
while (line := sys.stdin.readline().strip()):
    results.append(process(line))

Now the loop reads, strips, and checks for emptiness in one concise line. In a list comprehension you’d write:

results = [process(line) for line in sys.stdin if (line := line.strip())]

(Note: the inner line := line.strip() works because the assignment expression returns the stripped value, which is then tested for truthiness.)

Why does this make you a better coder? It reduces boilerplate, cuts down on accidental reuse of stale variables, and makes the flow of data obvious at a glance — exactly the kind of readability that saves minutes during a heated contest.

2. itertools.accumulate – Custom Prefix Operations

The Struggle

The classic prefix‑sum problem: given an array a, produce an array p where p[i] = a[0] + a[1] + … + a[i]. Many contestants manually loop and accumulate:

prefix = [0] * len(a)
running = 0
for i, val in enumerate(a):
    running += val
    prefix[i] = running

Fine for sums, but what if you need prefix XOR, prefix minimum, or even a running product modulo a prime? You’d end up rewriting the loop each time.

The Gotcha

itertools.accumulate defaults to summation, but you can pass any binary function — operator.xor, min, or a lambda. The subtlety? The function receives the previous accumulated value and the next element, not the element alone. Forgetting this leads to off‑by‑one errors.

The Victory

import itertools
import operator

# Prefix sum
prefix_sum = list(itertools.accumulate(a))

# Prefix XOR
prefix_xor = list(itertools.accumulate(a, operator.xor))

# Prefix minimum
prefix_min = list(itertools.accumulate(a, min))

# Running product modulo MOD
MOD = 1_000_000_007
prefix_prod = list(itertools.accumulate(a, lambda x, y: (x * y) % MOD))

One line, zero manual bookkeeping, and the intent shines through. In a contest where you might need several different prefix metrics back‑to‑back, this trick turns a repetitive block into a readable declarative style.

3. collections.deque – Sliding Window Max/Min in O(n)

The Struggle

A common CP problem: given an array and a window size k, output the maximum (or minimum) for each contiguous sub‑array of length k. The naive approach scans the window each time → O(n·k). Many reach for a heap, but deletions are lazy and messy.

The Gotcha

deque gives O(1) appends and pops from both ends, but you must maintain monotonic order manually. If you push a new element while forgetting to discard smaller (or larger) elements from the tail, the deque will stale and produce wrong answers.

The Victory

from collections import deque

def sliding_window_max(arr, k):
    q = deque()          # stores indices, values in decreasing order
    result = []
    for i, val in enumerate(arr):
        # Remove indices that are out of the current window
        if q and q[0] <= i - k:
            q.popleft()
        # Remove from back all elements smaller than current (useless for max)
        while q and arr[q[-1]] <= val:
            q.pop()
        q.append(i)
        # The front holds the max for the window ending at i
        if i >= k - 1:
            result.append(arr[q[0]])
    return result

# Example
print(sliding_window_max([1,3,-1,-3,5,3,6,7], 3))
# → [3, 3, 5, 5, 6, 7]

The same structure works for minima by flipping the comparison (>=). Because each index is pushed and popped at most once, the algorithm runs in O(n) time — a massive win over the naïve O(n·k) approach.

Why This New Power Matters

Mastering these three tricks does more than shave a few milliseconds off your runtime; it reshapes how you think about problems.

• The walrus operator teaches you to express intent directly, reducing the cognitive load of tracking temporary variables.
• itertools.accumulate shows the power of higher‑order thinking: you stop writing loops for every aggregation and start composing functions.
• collections.deque reinforces the importance of data‑structure invariants — maintaining a monotonic queue is a pattern that reappears in countless advanced problems (monotonic stacks, convex hull tricks, etc.).

When you internalize these patterns, you stop solving each problem from scratch and start recognizing familiar shapes. That’s the difference between grinding through a contest and flowing through it like Neo dodging bullets — smooth, confident, and unstoppable.

Your Turn – A Mini‑Quest

Pick a problem you’ve struggled with recently (maybe “longest subarray with sum ≤ S” or “minimum cost to make array non‑decreasing”). Try to rewrite your solution using one of the tricks above. Share your before/after snippets in the comments — let’s see who can level up their CP game the fastest!

Happy hacking, and may your code always be as sharp as a katana in a cyber‑punk showdown. 🚀