Top 30 Python Coding Challenges with Solutions [2026]

Beginner Challenges

These test strings, lists and dicts. Watch for the idiomatic version: slicing, comprehensions and collections instead of index loops.

1. Check whether a sentence is a palindrome.

Task: ignore case and anything that is not a letter or digit. "A man, a plan, a canal: Panama" returns True.

def is_palindrome(s: str) -> bool:
    cleaned = [c.lower() for c in s if c.isalnum()]
    return cleaned == cleaned[::-1]

O(n) time and O(n) memory. str.isalnum() is Unicode-aware, so accented letters count as letters. A two-pointer loop brings memory down to O(1); ask for it as a follow-up.

2. Return the k most common words in a text.

Task: "the cat and the hat and the bat" with k = 3 returns [('the', 3), ('and', 2), ('cat', 1)].

import re
from collections import Counter

def top_words(text: str, k: int = 3) -> list[tuple[str, int]]:
    words = re.findall(r"[a-z']+", text.lower())
    return Counter(words).most_common(k)

most_common orders ties by first appearance, which is why cat beats hat. Splitting on spaces alone would count "the," and "the" as different words.

3. Find the index of the first character that does not repeat.

Task: "leetcode" returns 0, "loveleetcode" returns 2, and "aabb" returns -1.

from collections import Counter

def first_unique(s: str) -> int:
    counts = Counter(s)
    return next((i for i, c in enumerate(s) if counts[c] == 1), -1)

Two passes, O(n). The default argument of next() replaces a loop with a flag variable.

4. Check whether two phrases are anagrams.

Task: ignore spaces and case. "Dormitory" and "dirty room" return True.

from collections import Counter

def is_anagram(a: str, b: str) -> bool:
    def key(s: str) -> Counter[str]:
        return Counter(s.replace(" ", "").lower())
    return key(a) == key(b)

Comparing two Counters is O(n). sorted(a) == sorted(b) is shorter but O(n log n).

5. Flatten a list nested to any depth.

Task: [1, [2, [3, [4]], 5]] becomes [1, 2, 3, 4, 5].

from collections.abc import Iterator

def flatten(items: list) -> Iterator:
    for item in items:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

# list(flatten([1, [2, [3, [4]], 5]])) returns [1, 2, 3, 4, 5]

A generator yields values lazily, so it never builds lists in between. The trap is checking for any iterable instead of list: a one-letter string is iterable and yields itself, so the recursion never ends.

6. Rotate a list to the right by k steps.

Task: [1, 2, 3, 4, 5, 6, 7] with k = 3 returns [5, 6, 7, 1, 2, 3, 4]. k may be larger than the list.

def rotate(nums: list[int], k: int) -> list[int]:
    if not nums:
        return []
    k %= len(nums)
    return nums[-k:] + nums[:-k]

The modulo handles k larger than the list and the empty check avoids dividing by zero. When k is 0, nums[-0:] is the whole list and nums[:-0] is empty, so the result is still correct. collections.deque.rotate(k) does the same in place.

Advanced Challenges

Senior rounds add design, decorators, heaps and graphs. The follow-ups (thread safety, memory, what breaks at scale) matter more than the first draft.

17. Build an LRU cache with O(1) get and put.

Task: get returns -1 for a missing key; put evicts the least recently used key when the cache is full.

from collections import OrderedDict

class LRUCache:
    def __init__(self, capacity: int) -> None:
        self.capacity = capacity
        self.data: OrderedDict[int, int] = OrderedDict()

    def get(self, key: int) -> int:
        if key not in self.data:
            return -1
        self.data.move_to_end(key)
        return self.data[key]

    def put(self, key: int, value: int) -> None:
        self.data[key] = value
        self.data.move_to_end(key)
        if len(self.data) > self.capacity:
            self.data.popitem(last=False)

move_to_end and popitem(last=False) are both O(1). To cache a function's results, functools.lru_cache(maxsize=...) already does this. The class is not thread-safe; ask how the candidate would add a lock.

18. Write a retry decorator that takes arguments.

Task: @retry(times=3, exceptions=(ConnectionError,)) retries a failing call with growing delays, then re-raises the last error.

import functools
import time

def retry(times: int = 3, delay: float = 0.1, exceptions=(Exception,)):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions:
                    if attempt == times:
                        raise
                    time.sleep(delay * 2 ** (attempt - 1))
        return wrapper
    return decorator

@retry(times=3, exceptions=(ConnectionError,))
def fetch_price(symbol: str) -> float: ...

A decorator with arguments is a function that returns a decorator, hence three levels. functools.wraps keeps the wrapped function's name and docstring. A bare raise re-raises the original error with its traceback.

19. Merge k sorted linked lists.

Task: merge 1-4-5, 1-3-4 and 2-6 into 1-1-2-3-4-4-5-6.

import heapq

def merge_k_lists(lists: list[ListNode | None]) -> ListNode | None:
    heap = [(node.val, i, node) for i, node in enumerate(lists) if node]
    heapq.heapify(heap)
    dummy = tail = ListNode(0)
    while heap:
        _, i, node = heapq.heappop(heap)
        tail.next = node
        tail = node
        if node.next:
            heapq.heappush(heap, (node.next.val, i, node.next))
    return dummy.next

O(N log k) for N nodes in k lists. The index i is the trap: without it, two equal values make Python compare two ListNode objects, which raises TypeError. For plain sorted lists, heapq.merge(*lists) does the whole job.

20. Keep the running median of a stream.

Task: after adding 1 and 2 the median is 1.5; after adding 3 it is 2.

import heapq

class MedianFinder:
    def __init__(self) -> None:
        self.low: list[int] = []    # max-heap, stored negated
        self.high: list[int] = []   # min-heap

    def add(self, num: int) -> None:
        heapq.heappush(self.low, -num)
        heapq.heappush(self.high, -heapq.heappop(self.low))
        if len(self.high) > len(self.low):
            heapq.heappush(self.low, -heapq.heappop(self.high))

    def median(self) -> float:
        if len(self.low) > len(self.high):
            return float(-self.low[0])
        return (-self.low[0] + self.high[0]) / 2

add is O(log n) and median is O(1). Before 3.14, heapq only had min-heap functions, so the lower half is stored negated. Challenge 32 shows the 3.14 version.

21. Find the fewest coins that make an amount.

Task: coins [1, 2, 5] and amount 11 return 3. If no combination works, return -1.

def coin_change(coins: list[int], amount: int) -> int:
    dp = [0] + [float("inf")] * amount
    for a in range(1, amount + 1):
        for coin in coins:
            if coin <= a:
                dp[a] = min(dp[a], dp[a - coin] + 1)
    return -1 if dp[amount] == float("inf") else int(dp[amount])

O(amount x coins). Greedy fails for coins [1, 3, 4] and amount 6: it picks 4 + 1 + 1, but 3 + 3 uses two coins.

22. Can a string be split into dictionary words?

Task: "leetcode" with ["leet", "code"] returns True; "catsandog" with ["cats", "dog", "sand", "and", "cat"] returns False.

from functools import cache

def word_break(s: str, words: list[str]) -> bool:
    vocab = set(words)

    @cache
    def can_split(i: int) -> bool:
        if i == len(s):
            return True
        return any(s[i:j] in vocab and can_split(j) for j in range(i + 1, len(s) + 1))

    return can_split(0)

functools.cache turns the recursive search into top-down dynamic programming, O(n²) substring checks. Without it the same suffixes are solved again and again, which is exponential.

The recursion depth equals the string length, so a bottom-up table suits very long inputs.

23. Find the shortest distance from one node to every other.

Task: edge weights are positive. From A, with A to B = 4, A to C = 1, C to B = 2, C to D = 5 and B to D = 1, return A 0, C 1, B 3, D 4.

import heapq

def shortest_paths(graph: dict[str, list[tuple[str, int]]], start: str) -> dict[str, int]:
    dist = {start: 0}
    heap = [(0, start)]
    while heap:
        d, node = heapq.heappop(heap)
        if d > dist[node]:
            continue                      # stale entry, already improved
        for nxt, weight in graph.get(node, []):
            nd = d + weight
            if nd < dist.get(nxt, float("inf")):
                dist[nxt] = nd
                heapq.heappush(heap, (nd, nxt))
    return dist

Dijkstra's algorithm, O((V + E) log V). heapq cannot lower a key in place, so the code pushes a new entry and skips stale ones when they come out. Negative weights break it; Bellman-Ford handles those.

24. Order build steps so every dependency comes first.

Task: app needs lib and config, and lib needs config. Return a valid order, or None if there is a cycle.

from graphlib import CycleError, TopologicalSorter

def build_order(deps: dict[str, set[str]]) -> list[str] | None:
    try:
        return list(TopologicalSorter(deps).static_order())
    except CycleError:
        return None

# build_order({"app": {"lib", "config"}, "lib": {"config"}})
# returns ['config', 'lib', 'app']

graphlib has been in the standard library since Python 3.9. A strong candidate uses it, then writes Kahn's algorithm by hand when asked: count incoming edges, and repeatedly take nodes whose count is zero.

25. Build a sliding-window rate limiter.

Task: allow at most limit calls in any window seconds. With limit 2 and a 1-second window, calls at 0.0, 0.1 and 0.2 return True, True, False, and a call at 1.05 returns True.

import time
from collections import deque

class RateLimiter:
    def __init__(self, limit: int, window: float) -> None:
        self.limit = limit
        self.window = window
        self.calls: deque[float] = deque()

    def allow(self, now: float | None = None) -> bool:
        now = time.monotonic() if now is None else now
        while self.calls and now - self.calls[0] >= self.window:
            self.calls.popleft()
        if len(self.calls) < self.limit:
            self.calls.append(now)
            return True
        return False

Each call is amortized O(1), and memory is O(limit). time.monotonic() matters: time.time() can jump when the system clock changes. Passing now in makes the class testable without sleeping.

Signs of a Strong Answer

• They reach for Counter, defaultdict, deque, heapq and bisect first, and can write the manual version when asked.
• They use deque.popleft() for queues and can say why list.pop(0) is O(n).
• They add a tie-breaker to heap tuples before the TypeError happens.
• They pick BFS or an explicit stack on large inputs because of the 1,000-frame recursion limit.
• They state which Python version a feature needs, such as copy.replace (3.13) or t-strings (3.14).
• They know threads speed up CPU-bound Python only on the free-threaded build.