Level Up Your Code: Python Tricks for Competitive Programming — Like Neo Dodging Bullets

The Quest Begins (The "Why")

Honestly, I remember the first time I walked into a Codeforces round feeling completely outgunned. I’d spent hours polishing my solution, only to watch it time‑out because I was looping over a list a thousand times when a single pass would’ve done the job. I was stuck in that frustrating loop where my brain kept shouting “there’s gotta be a smarter way!” while my fingers hammered out the same old brute‑force code. It felt like trying to defeat a boss with a wooden sword — yeah, you’ll eventually win, but the fight drags on forever and you lose precious rating points.

That frustration pushed me to dig deeper into Python’s standard library. I wasn’t looking for fancy third‑party packages; I wanted the built‑in tricks that could shave off milliseconds without adding complexity. What I uncovered felt like finding hidden cheat codes in a classic game — simple, powerful, and totally legal.

The Revelation (The Insight)

The first gem that blew my mind was itertools.accumulate. Most of us reach for a manual loop when we need prefix sums or running totals, but accumulate does the heavy lifting in C‑speed and returns an iterator. The gotcha? It’s lazy — if you forget to wrap it in list() (or consume it in a loop), you’ll end up printing something like <itertools.accumulate object at 0x...>, which is about as useful as a chocolate teapot.

The second surprise was the bisect module. Binary search sounds intimidating, but bisect_left and bisect_right give you the exact insertion point for a value in a sorted list in O(log n) time. The trap here is assuming the list is sorted — if it isn’t, you’ll get nonsense results, and debugging why your “search” always returns zero can feel like chasing a ghost.

Finally, the walrus operator (:=) — introduced in Python 3.8 — lets you assign and test a value in a single expression. It looks like a tiny glyph, but it can collapse messy nested loops into readable one‑liners. The pitfall? You can’t use it in places where a statement‑that‑expect‑a‑pure‑expression, like the iterable part of a for loop (unless you’re on 3.12+ where it’s relaxed), and overusing it can make code look like line noise if you’re not careful.

Each of these features solved a real pain point I’d been ignoring, and once I saw the pattern, I started spotting opportunities everywhere.

Wielding the Power (Code & Examples)

1. Prefix sums with itertools.accumulate

The struggle:

# O(n²) naïve approach for each query
def solve_naive(arr, queries):
    res = []
    for l, r in queries:
        total = 0
        for i in range(l, r + 1):
            total += arr[i]
        res.append(total)
    return res

If arr has 10⁵ elements and you get 10⁵ queries, you’re looking at ~10¹⁰ operations — definitely a TLE.

The victory:

from itertools import accumulate

def solve_fast(arr, queries):
    # Build prefix sums once: pref[i] = sum(arr[0:i])
    pref = list(accumulate(arr, initial=0))   # <-- note the initial=0 for 1‑based ease
    res = [pref[r + 1] - pref[l] for l, r in queries]
    return res

accumulate does the cumulative addition in C, turning an O(n²) nightmare into O(n + q). The initial=0 argument (available from Python 3.8) lets us avoid off‑by‑one headaches — just remember to wrap the iterator in list() if you need random access later.

2. Binary search with bisect

The struggle:

# Linear scan to find first element >= x
def lower_bound_linear(arr, x):
    for i, v in enumerate(arr):
        if v >= x:
            return i
    return len(arr)

Again, O(n) per query — painful when you need to do this many times.

The victory:

import bisect

def lower_bound_fast(arr, x):
    # Returns the leftmost index where arr[idx] >= x
    return bisect.bisect_left(arr, x)

The list must be sorted beforehand; otherwise the result is meaningless. A quick arr.sort() before the queries (or maintaining a sorted structure) turns each search into O(log n).

3. Inline assignment with the walrus operator

The struggle:

# Reading lines until an empty one appears
lines = []
while True:
    line = input()
    if line == "":
        break
    lines.append(line)

You repeat the input() call and then test it — fine, but a bit noisy.

The victory:

lines = []
while (line := input()) != "":
    lines.append(line)

The walrus captures the line and tests it in one go. It’s especially handy in list comprehensions where you need the intermediate value:

# Keep only numbers that are perfect squares, and also store their roots
import math
nums = [2, 3, 4, 5, 9, 16, 20]
sq_roots = [r for n in nums if (r := int(math.isqrt(n))) ** 2 == n]
# sq_roots -> [2, 3, 4]

Just keep in mind: the walrus is an expression, not a statement, so you can’t slap it wherever you feel like — put it where Python expects a value (inside a condition, comprehension, or lambda).

Why This New Power Matters

Mastering these tricks does more than shave a few milliseconds off your runtime — it changes how you think about problems. When you see a need for a running total, your first instinct becomes “let’s reach for accumulate”, not “let’s nest another loop”. When you need to locate a position in a sorted sequence, bisect feels as natural as reaching for a sword in your inventory. And the walrus? It lets you write code that reads almost like prose, reducing the cognitive load when you (or a teammate) revisit it months later.

In competitive programming, those small wins add up. A solution that once hovered at the edge of the time limit now flies through with room to spare, letting you tackle harder problems or experiment with optimizations you previously feared. Beyond contests, these patterns make your everyday scripts cleaner and more maintainable — because who doesn’t want to feel like they’ve got the Force guiding their code?

Your Turn

Pick a problem you’ve solved recently with a manual loop or a linear scan. Try rewriting it using one of the three tricks above. Did the runtime drop? Did the code feel sharper? Drop your solution (or just your thoughts) in the comments — I’d love to see how these spells work in your own quest.

Happy hacking, and may your bugs be few and your victories swift! 🚀