Blind 75 — Pattern Walkthrough

# Two Sum — the hash map template
def two_sum(nums, target):
    seen = {}
    for i, x in enumerate(nums):
        if target - x in seen:
            return [seen[target - x], i]
        seen[x] = i
    return []

# Maximum Subarray — Kadane's algorithm
def max_subarray(nums):
    curr_sum = max_sum = nums[0]
    for n in nums[1:]:
        curr_sum = max(n, curr_sum + n)  # reset if negative prefix
        max_sum = max(max_sum, curr_sum)
    return max_sum

// Two Sum in Java
import java.util.HashMap;
public class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> seen = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int partner = target - nums[i];
            if (seen.containsKey(partner))
                return new int[]{seen.get(partner), i};
            seen.put(nums[i], i);
        }
        return new int[]{};
    }
}

// Two Sum in C++
#include <unordered_map>
#include <vector>
using namespace std;
vector<int> twoSum(vector<int>& nums, int target) {
    unordered_map<int, int> seen;
    for (int i = 0; i < (int)nums.size(); i++) {
        int partner = target - nums[i];
        if (seen.count(partner)) return {seen[partner], i};
        seen[nums[i]] = i;
    }
    return {};
}

# Tree max depth — the 3-line template every tree problem starts from
def max_depth(root):
    if not root:
        return 0
    return 1 + max(max_depth(root.left), max_depth(root.right))

# Level order traversal — BFS queue
from collections import deque
def level_order(root):
    if not root: return []
    result, queue = [], deque([root])
    while queue:
        level = []
        for _ in range(len(queue)):  # freeze current level size
            node = queue.popleft()
            level.append(node.val)
            if node.left: queue.append(node.left)
            if node.right: queue.append(node.right)
        result.append(level)
    return result

// Tree max depth — Java
public int maxDepth(TreeNode root) {
    if (root == null) return 0;
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}

// Tree max depth — C++
int maxDepth(TreeNode* root) {
    if (!root) return 0;
    return 1 + max(maxDepth(root->left), maxDepth(root->right));
}