Python Coding Patterns

1. NumPy Essentials

Array Creation and Vectorized Operations

NumPy arrays replace loops with compiled C operations. The performance difference is routinely 10–100x for large arrays.

import numpy as np

arr     = np.array([1, 2, 3, 4, 5])
zeros   = np.zeros((3, 4))
arange  = np.arange(0, 10, 0.5)      # start, stop, step
linspace = np.linspace(0, 1, 100)    # start, stop, num_points

# Vectorized arithmetic — no loops needed
arr * 2           # [2, 4, 6, 8, 10]
arr ** 2          # [1, 4, 9, 16, 25]
np.sqrt(arr)
np.log(arr)       # natural log

# Broadcasting: add a row vector to each row of a matrix
matrix = np.arange(12).reshape(3, 4)  # shape (3, 4)
row    = np.array([1, 2, 3, 4])       # shape (4,)
matrix + row                           # broadcast along axis 0

Boolean Indexing and Masking

arr = np.array([10, -5, 3, -1, 8, 0])

positive = arr[arr > 0]        # [10, 3, 8]
arr[arr < 0] = 0               # clip negatives in-place

# np.where: vectorized if/else
np.where(arr > 0, arr, 0)      # positive values, else 0
np.where(arr > 5, 'high', 'low')

Aggregations

arr = np.array([[1, 2, 3], [4, 5, 6]])
arr.sum()             # 21 (all elements)
arr.sum(axis=0)       # [5, 7, 9] — column sums
arr.sum(axis=1)       # [6, 15]   — row sums
arr.mean(axis=1)      # [2.0, 5.0]
np.percentile(arr, [25, 50, 75])
arr.argmax(axis=1)    # index of max per row

2. Efficient Python Patterns

Comprehensions

# List comprehension — prefer over for-loop
squares = [x**2 for x in range(10)]
evens   = [x for x in range(20) if x % 2 == 0]

# Dict comprehension
word_len = {word: len(word) for word in ['apple', 'banana', 'fig']}

# Nested — flatten a 2D list
flat = [x for row in matrix for x in row]

collections Module

from collections import Counter, defaultdict, deque

# Counter — frequency map in one line
text   = "the quick brown fox jumps over the lazy dog"
counts = Counter(text.split())   # {'the': 2, 'quick': 1, ...}
counts.most_common(3)

# defaultdict — no KeyError on missing keys
graph = defaultdict(list)
graph['A'].append('B')   # works even if 'A' not yet in dict

# deque — O(1) popleft (list.pop(0) is O(n))
queue = deque([1, 2, 3])
queue.appendleft(0)   # O(1)
queue.popleft()        # O(1)

Built-in Functions

names  = ['Alice', 'Bob', 'Carol']
scores = [88, 92, 79]

# zip — iterate multiple sequences together
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# enumerate — index + value, no counter variable
for i, name in enumerate(names, start=1):
    print(f"{i}. {name}")

# sorted with key
people = [('Alice', 30), ('Bob', 25), ('Carol', 35)]
by_age = sorted(people, key=lambda x: x[1])
oldest = max(people, key=lambda x: x[1])   # ('Carol', 35)

# String join: always O(n) — prefer over repeated +=
sentence = ' '.join(['data', 'science', 'at', 'capital', 'one'])

3. Time Complexity Cheat Sheet

4. Common CodeSignal Patterns

Sliding Window — O(n)

def max_sum_subarray(arr, k):
    """Max sum of any contiguous subarray of length k."""
    window = sum(arr[:k])
    best   = window
    for i in range(k, len(arr)):
        window += arr[i] - arr[i - k]
        best = max(best, window)
    return best

HashMap for O(1) Lookup

def two_sum(nums, target):
    seen = {}   # value -> index
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

Frequency Counter (avoid O(n²) nested loops)

from collections import Counter

def find_duplicates(arr):
    counts = Counter(arr)
    return [k for k, v in counts.items() if v > 1]

5. Graph Algorithms

Graph problems appear frequently in DS coding assessments. Master BFS for shortest paths in unweighted graphs, DFS for connectivity/cycle detection, and topological sort for dependency ordering.

Graph Representation

from collections import defaultdict, deque

# Adjacency list (preferred for sparse graphs)
graph = defaultdict(list)
edges = [(0,1),(0,2),(1,3),(2,3),(3,4)]
for u, v in edges:
    graph[u].append(v)
    graph[v].append(u)  # omit for directed graphs

Breadth-First Search (BFS)

Explores level by level. Finds shortest path in unweighted graphs. Time: $O(V + E)$.

def bfs_shortest_path(graph, start, end):
    if start == end:
        return [start]
    visited = {start}
    queue = deque([(start, [start])])  # (node, path)
    while queue:
        node, path = queue.popleft()
        for neighbor in graph[node]:
            if neighbor not in visited:
                new_path = path + [neighbor]
                if neighbor == end:
                    return new_path
                visited.add(neighbor)
                queue.append((neighbor, new_path))
    return []  # no path exists

# BFS for level-order / minimum steps
def bfs_levels(graph, start):
    dist = {start: 0}
    queue = deque([start])
    while queue:
        node = queue.popleft()
        for neighbor in graph[node]:
            if neighbor not in dist:
                dist[neighbor] = dist[node] + 1
                queue.append(neighbor)
    return dist

Depth-First Search (DFS)

Explores one branch fully before backtracking. Use for connected components, cycle detection, path existence. Time: $O(V + E)$.

def dfs_recursive(graph, node, visited=None):
    if visited is None:
        visited = set()
    visited.add(node)
    for neighbor in graph[node]:
        if neighbor not in visited:
            dfs_recursive(graph, neighbor, visited)
    return visited

def dfs_iterative(graph, start):
    visited = set()
    stack = [start]
    while stack:
        node = stack.pop()
        if node not in visited:
            visited.add(node)
            stack.extend(graph[node])
    return visited

# Count connected components
def count_components(n, edges):
    graph = defaultdict(list)
    for u, v in edges:
        graph[u].append(v)
        graph[v].append(u)
    visited = set()
    components = 0
    for node in range(n):
        if node not in visited:
            dfs_iterative_mark(graph, node, visited)
            components += 1
    return components

Topological Sort (Kahn's Algorithm)

For directed acyclic graphs (DAGs). Returns nodes in dependency order. Detects cycles if not all nodes are processed. Use for task scheduling, build systems, course prerequisites.

def topological_sort(n, prerequisites):
    graph = defaultdict(list)
    in_degree = [0] * n
    for course, prereq in prerequisites:
        graph[prereq].append(course)
        in_degree[course] += 1

    queue = deque([i for i in range(n) if in_degree[i] == 0])
    order = []
    while queue:
        node = queue.popleft()
        order.append(node)
        for neighbor in graph[node]:
            in_degree[neighbor] -= 1
            if in_degree[neighbor] == 0:
                queue.append(neighbor)

    return order if len(order) == n else []  # empty = cycle detected

6. Binary Search

Binary search runs in $O(\log n)$ and applies beyond sorted arrays — any time a decision space is monotonic (if a value works, all values on one side also work), binary search on the answer.

Standard Template

import bisect

# Built-in: bisect_left returns first index where val could be inserted (< val or == val)
arr = [1, 3, 5, 7, 9]
idx = bisect.bisect_left(arr, 5)   # → 2 (first position with value >= 5)
idx = bisect.bisect_right(arr, 5)  # → 3 (first position with value > 5)

# Manual template (handles edge cases safely)
def binary_search(arr, target):
    lo, hi = 0, len(arr) - 1
    while lo <= hi:
        mid = lo + (hi - lo) // 2   # avoids integer overflow
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            lo = mid + 1
        else:
            hi = mid - 1
    return -1  # not found

# Find leftmost index where condition becomes True (binary search on answer)
def first_true(lo, hi, condition):
    """Returns smallest x in [lo, hi] where condition(x) is True."""
    while lo < hi:
        mid = (lo + hi) // 2
        if condition(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo

Binary Search on Answer Pattern

# Classic: can we allocate work across k workers such that max load <= capacity?
def can_allocate(tasks, k, max_load):
    workers = 1
    current = 0
    for t in tasks:
        if t > max_load:
            return False
        if current + t > max_load:
            workers += 1
            current = t
        else:
            current += t
    return workers <= k

def min_max_load(tasks, k):
    lo, hi = max(tasks), sum(tasks)
    return first_true(lo, hi, lambda cap: can_allocate(tasks, k, cap))

Common Patterns

• Search in rotated sorted array: find pivot with binary search, then search the right half
• Find peak element: compare mid with mid+1; move toward the larger side
• Sqrt(x): binary search on integers in $[0, x]$; return last value where $\text{mid}^2 \leq x$
• bisect.insort(arr, val): insert val into sorted list in $O(\log n + n)$; useful for maintaining a sorted running window

7. Dynamic Programming and Heaps

Dynamic Programming

DP solves problems by breaking them into overlapping subproblems and storing results to avoid recomputation. Key insight: identify a recurrence relation, then implement with memoization (top-down) or tabulation (bottom-up).

from functools import lru_cache

# --- Memoization (top-down) ---
@lru_cache(maxsize=None)
def fib(n):
    if n <= 1:
        return n
    return fib(n-1) + fib(n-2)

# --- Tabulation (bottom-up) ---
def coin_change(coins, amount):
    """Minimum coins to make amount. Returns -1 if impossible."""
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0
    for amt in range(1, amount + 1):
        for coin in coins:
            if coin <= amt:
                dp[amt] = min(dp[amt], dp[amt - coin] + 1)
    return dp[amount] if dp[amount] != float('inf') else -1

# --- Longest Common Subsequence ---
def lcs(s1, s2):
    m, n = len(s1), len(s2)
    dp = [[0]*(n+1) for _ in range(m+1)]
    for i in range(1, m+1):
        for j in range(1, n+1):
            if s1[i-1] == s2[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
    return dp[m][n]

# --- 0/1 Knapsack ---
def knapsack(weights, values, capacity):
    n = len(weights)
    dp = [[0]*(capacity+1) for _ in range(n+1)]
    for i in range(1, n+1):
        for w in range(capacity+1):
            dp[i][w] = dp[i-1][w]  # don't take item i
            if weights[i-1] <= w:
                dp[i][w] = max(dp[i][w], dp[i-1][w-weights[i-1]] + values[i-1])
    return dp[n][capacity]

heapq — Priority Queue

Python's heapq is a min-heap. Negate values for max-heap. $O(\log n)$ push and pop; $O(n)$ heapify.

import heapq

# Min-heap
heap = [3, 1, 4, 1, 5]
heapq.heapify(heap)                 # O(n) in-place
heapq.heappush(heap, 2)             # push
smallest = heapq.heappop(heap)      # pop smallest: O(log n)

# Max-heap: negate values
max_heap = [-x for x in [3, 1, 4, 1, 5]]
heapq.heapify(max_heap)
largest = -heapq.heappop(max_heap)

# K largest / K smallest
nums = [3, 1, 4, 1, 5, 9, 2, 6]
k_largest  = heapq.nlargest(3, nums)   # [9, 6, 5]
k_smallest = heapq.nsmallest(3, nums)  # [1, 1, 2]

# Pattern: running median with two heaps
class MedianFinder:
    def __init__(self):
        self.lo = []   # max-heap (negate): lower half
        self.hi = []   # min-heap: upper half

    def add(self, num):
        heapq.heappush(self.lo, -num)
        heapq.heappush(self.hi, -heapq.heappop(self.lo))
        if len(self.hi) > len(self.lo):
            heapq.heappush(self.lo, -heapq.heappop(self.hi))

    def median(self):
        if len(self.lo) > len(self.hi):
            return -self.lo[0]
        return (-self.lo[0] + self.hi[0]) / 2

# Pattern: K closest points to origin
def k_closest(points, k):
    return heapq.nsmallest(k, points, key=lambda p: p[0]**2 + p[1]**2)

DP Complexity Cheat Sheet