Hash Table: Practice Problems with Solutions

Coding Patterns - Guide to 30 Core Algorithm Patterns

Hash Table Pattern: Complete Guide with Examples

Welcome to the practice problems for hash tables. If you need a refresher on the code, the code templates have the patterns in all 6 languages. Each problem below includes a hint, a visual walkthrough, and the full solution.

Recommended Study Order

Work through the problems in the order they appear. Contains Duplicate teaches the membership check with a set. Two Sum adds the complement search, and Ransom Note adds decrementing counts. The Medium problems each add one twist. Group Anagrams builds a canonical key. Intersection of Two Arrays II combines counting with consumption. Longest Consecutive Sequence turns the set into a linear-time algorithm. LRU Cache is the capstone. It pairs the map with a linked list, and both halves must be correct for it to work.

The order above is designed to build intuition progressively. The app schedules your reviews so you do not forget the Easy patterns while grinding Hard ones. Set up your review schedule .

Easy Problems

1. Contains Duplicate

LeetCode 217 | Difficulty: Easy

Brief: determine whether any value in an array appears more than once.

Why this pattern: membership testing is the purest hash table use. A set records what you have seen, and the first repeat is the answer.

Key Insight: you do not need counts. Existence is enough, which is exactly what a set provides.

Visual:

    graph LR
    A["nums = [1,2,3,1]"] --> B["seen = {}"]
    B --> C["1: not seen, add"]
    C --> D["2: not seen, add"]
    D --> E["3: not seen, add"]
    E --> F["1: already seen, return true"]

Code:

var containsDuplicate = function(nums) {
    const seen = new Set();

    for (const num of nums) {
        if (seen.has(num)) {
            return true;
        }
        seen.add(num);
    }

    return false;
};

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        seen = set()

        for num in nums:
            if num in seen:
                return True
            seen.add(num)

        return False

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Set<Integer> seen = new HashSet<>();

        for (int num : nums) {
            if (seen.contains(num)) {
                return true;
            }
            seen.add(num);
        }

        return false;
    }
}

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        unordered_set<int> seen;

        for (int num : nums) {
            if (seen.find(num) != seen.end()) {
                return true;
            }
            seen.insert(num);
        }

        return false;
    }
};

func containsDuplicate(nums []int) bool {
    seen := make(map[int]bool)

    for _, num := range nums {
        if seen[num] {
            return true
        }
        seen[num] = true
    }

    return false
}

The early exit matters. As soon as a duplicate appears, the answer is known and the loop stops. The worst case is an array with no duplicates, where every element ends up in the set. Time is

O(N)

and space is

O(N)

2. Two Sum

LeetCode 1 | Difficulty: Easy

Brief: return the indices of the two numbers that add up to a target.

Why this pattern: complement search. For each number, the partner you need is the target minus the number. Store what you have seen, check what you still need.

Key Insight: check the map before storing the current number. Otherwise an element can pair with itself.

Visual:

    graph LR
    A["nums = [2,7,11,15], target = 9"] --> B["map = {}"]
    B --> C["2: need 7. Not seen. Store 2 at index 0"]
    C --> D["7: need 2. Seen at index 0. Return [0, 1]"]

Code:

var twoSum = function(nums, target) {
    const seen = new Map();

    for (let i = 0; i < nums.length; i++) {
        const complement = target - nums[i];

        // Check before storing so the current element
        // cannot pair with itself.
        if (seen.has(complement)) {
            return [seen.get(complement), i];
        }

        seen.set(nums[i], i);
    }

    return [];
};

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        seen = {}

        for i, num in enumerate(nums):
            complement = target - num

            if complement in seen:
                return [seen[complement], i]

            seen[num] = i

        return []

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> seen = new HashMap<>();

        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];

            if (seen.containsKey(complement)) {
                return new int[]{seen.get(complement), i};
            }

            seen.put(nums[i], i);
        }

        return new int[]{};
    }
}

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> seen;

        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];

            if (seen.find(complement) != seen.end()) {
                return {seen[complement], i};
            }

            seen[nums[i]] = i;
        }

        return {};
    }
};

def two_sum(nums, target)
    seen = {}

    nums.each_with_index do |num, i|
        complement = target - num

        return [seen[complement], i] if seen.key?(complement)

        seen[num] = i
    end

    []
end

The map stores value to index, and each element is visited once. Time is

O(N)

and space is

O(N)

. The check-then-store order is the one detail that separates a bug from a solution, and it is worth tracing with nums = [3] and target = 6 to see why.

3. Ransom Note

LeetCode 383 | Difficulty: Easy

Brief: decide whether the letters in a magazine can build a ransom note, with each letter used at most once.

Why this pattern: frequency counting with decrement. Count the magazine letters, then consume them one by one for the note.

Key Insight: counts, not booleans. A letter used twice in the note needs two copies in the magazine.

Visual:

    graph LR
    A["magazine = aab"] --> B["counts: a=2, b=1"]
    B --> C["note = aba"]
    C --> D["a: 2 to 1. b: 1 to 0. a: 1 to 0"]
    D --> E["All letters found. Return true"]

Code:

var canConstruct = function(ransomNote, magazine) {
    const counts = new Map();

    for (const ch of magazine) {
        counts.set(ch, (counts.get(ch) || 0) + 1);
    }

    for (const ch of ransomNote) {
        if (!counts.has(ch) || counts.get(ch) === 0) {
            return false;
        }
        counts.set(ch, counts.get(ch) - 1);
    }

    return true;
};

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        counts = {}

        for ch in magazine:
            counts[ch] = counts.get(ch, 0) + 1

        for ch in ransomNote:
            if counts.get(ch, 0) == 0:
                return False
            counts[ch] -= 1

        return True

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        Map<Character, Integer> counts = new HashMap<>();

        for (char c : magazine.toCharArray()) {
            counts.put(c, counts.getOrDefault(c, 0) + 1);
        }

        for (char c : ransomNote.toCharArray()) {
            if (!counts.containsKey(c) || counts.get(c) == 0) {
                return false;
            }
            counts.put(c, counts.get(c) - 1);
        }

        return true;
    }
}

class Solution {
public:
    bool canConstruct(string ransomNote, string magazine) {
        unordered_map<char, int> counts;

        for (char c : magazine) {
            counts[c]++;
        }

        for (char c : ransomNote) {
            if (counts[c] == 0) {
                return false;
            }
            counts[c]--;
        }

        return true;
    }
};

func canConstruct(ransomNote string, magazine string) bool {
    counts := make(map[rune]int)

    for _, ch := range magazine {
        counts[ch]++
    }

    for _, ch := range ransomNote {
        if counts[ch] == 0 {
            return false
        }
        counts[ch]--
    }

    return true
}

def can_construct(ransom_note, magazine)
    counts = Hash.new(0)

    magazine.each_char { |ch| counts[ch] += 1 }

    ransom_note.each_char do |ch|
        return false if counts[ch] == 0
        counts[ch] -= 1
    end

    true
end

The default value does the work. A letter that is not in the magazine reads as 0 and fails immediately, and an empty note passes because the second loop never runs. Each letter is handled once, so time is

O(N)

and space is

O(K)

where K is the number of distinct letters.

Medium Problems

4. Group Anagrams

LeetCode 49 | Difficulty: Medium

Brief: group strings that are anagrams of each other.

Why this pattern: grouping by a canonical key. Two anagrams share the same sorted form, so the sorted form is the key and the strings collect under it.

Key Insight: the key must be identical for every anagram and different otherwise. Sorting the letters gives exactly that.

Visual:

    graph LR
    A["eat"] --> B["key = aet"]
    C["tea"] --> B
    D["ate"] --> B
    B --> E["groups[aet] = [eat, tea, ate]"]
    F["tan"] --> G["key = ant"]
    G --> H["groups[ant] = [tan]"]

Code:

var groupAnagrams = function(strs) {
    const groups = new Map();

    for (const str of strs) {
        // Sorted letters are the canonical form:
        // every anagram produces the same key.
        const key = str.split('').sort().join('');

        if (!groups.has(key)) {
            groups.set(key, []);
        }
        groups.get(key).push(str);
    }

    return Array.from(groups.values());
};

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        groups = {}

        for s in strs:
            key = ''.join(sorted(s))
            groups.setdefault(key, []).append(s)

        return list(groups.values())

class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> groups = new HashMap<>();

        for (String str : strs) {
            char[] chars = str.toCharArray();
            Arrays.sort(chars);
            String key = new String(chars);

            groups.computeIfAbsent(key, k -> new ArrayList<>()).add(str);
        }

        return new ArrayList<>(groups.values());
    }
}

class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> groups;

        for (const string& str : strs) {
            string key = str;
            sort(key.begin(), key.end());
            groups[key].push_back(str);
        }

        vector<vector<string>> result;
        for (auto& pair : groups) {
            result.push_back(pair.second);
        }

        return result;
    }
};

func groupAnagrams(strs []string) [][]string {
    groups := make(map[string][]string)

    for _, str := range strs {
        key := sortString(str)
        groups[key] = append(groups[key], str)
    }

    result := [][]string{}
    for _, group := range groups {
        result = append(result, group)
    }

    return result
}

func sortString(s string) string {
    chars := []rune(s)
    sort.Slice(chars, func(i, j int) bool {
        return chars[i] < chars[j]
    })
    return string(chars)
}

Each string costs a sort, so the total is

O(N)

times the cost of sorting each string, where N is the number of strings and the sort cost depends on string length. Space is

O(N)

for the map. This problem also appears on the string manipulation problems page , framed around the string transforms themselves.

5. Intersection of Two Arrays II

LeetCode 350 | Difficulty: Medium

Brief: return the elements common to two arrays, including duplicates.

Why this pattern: frequency counting with consumption. Count one array, then take from the count for the other.

Key Insight: each element of the result must consume one unit of count, so a number cannot be counted more times than it appears.

Visual:

    graph LR
    A["nums1 = [1,2,2,1]"] --> B["freq: 1=2, 2=2"]
    B --> C["nums2 = [2,2]"]
    C --> D["2: count 2. Add. Count becomes 1"]
    D --> E["2: count 1. Add. Count becomes 0"]
    E --> F["result = [2,2]"]

Code:

var intersect = function(nums1, nums2) {
    const freq = new Map();
    const result = [];

    for (const num of nums1) {
        freq.set(num, (freq.get(num) || 0) + 1);
    }

    for (const num of nums2) {
        if (freq.has(num) && freq.get(num) > 0) {
            result.push(num);
            freq.set(num, freq.get(num) - 1);
        }
    }

    return result;
};

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        Map<Integer, Integer> freq = new HashMap<>();

        for (int num : nums1) {
            freq.put(num, freq.getOrDefault(num, 0) + 1);
        }

        List<Integer> result = new ArrayList<>();
        for (int num : nums2) {
            if (freq.containsKey(num) && freq.get(num) > 0) {
                result.add(num);
                freq.put(num, freq.get(num) - 1);
            }
        }

        return result.stream().mapToInt(Integer::intValue).toArray();
    }
}

class Solution {
public:
    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {
        unordered_map<int, int> freq;

        for (int num : nums1) {
            freq[num]++;
        }

        vector<int> result;
        for (int num : nums2) {
            if (freq[num] > 0) {
                result.push_back(num);
                freq[num]--;
            }
        }

        return result;
    }
};

The decrement is the point. Without it, a number appearing twice in nums2 would be counted twice even if nums1 had it once. Time and space are both

O(N)

in the size of the larger array.

6. Longest Consecutive Sequence

LeetCode 128 | Difficulty: Medium

Brief: find the length of the longest run of consecutive numbers. The solution must run in

O(N)

time.

Why this pattern: set membership checks. Store every number in a set, then walk each run forward.

Key Insight: only start counting at the beginning of a run. A number starts a run when its predecessor is not in the set. Every run gets counted exactly once, which is what keeps the time linear.

Visual:

    graph LR
    A["nums = [100,4,200,1,3,2]"] --> B["set = {1,2,3,4,100,200}"]
    B --> C["1: 0 not in set. Start. Run is 1,2,3,4. Length 4"]
    C --> D["100: 99 not in set. Start. Run is 100. Length 1"]
    D --> E["200: 199 not in set. Start. Run is 200. Length 1"]
    E --> F["longest = 4"]

Code:

var longestConsecutive = function(nums) {
    const numSet = new Set(nums);
    let longest = 0;

    for (const num of numSet) {
        // Only begin at the start of a run. If num - 1
        // exists, this number belongs to a longer run
        // and will be counted when that run starts.
        if (!numSet.has(num - 1)) {
            let current = num;
            let length = 1;

            while (numSet.has(current + 1)) {
                current++;
                length++;
            }

            longest = Math.max(longest, length);
        }
    }

    return longest;
};

class Solution:
    def longestConsecutive(self, nums: List[int]) -> int:
        num_set = set(nums)
        longest = 0

        for num in num_set:
            if num - 1 not in num_set:
                current = num
                length = 1

                while current + 1 in num_set:
                    current += 1
                    length += 1

                longest = max(longest, length)

        return longest

class Solution {
    public int longestConsecutive(int[] nums) {
        Set<Integer> numSet = new HashSet<>();

        for (int num : nums) {
            numSet.add(num);
        }

        int longest = 0;
        for (int num : numSet) {
            if (!numSet.contains(num - 1)) {
                int current = num;
                int length = 1;

                while (numSet.contains(current + 1)) {
                    current++;
                    length++;
                }

                longest = Math.max(longest, length);
            }
        }

        return longest;
    }
}

class Solution {
public:
    int longestConsecutive(vector<int>& nums) {
        unordered_set<int> numSet(nums.begin(), nums.end());
        int longest = 0;

        for (int num : numSet) {
            if (numSet.find(num - 1) == numSet.end()) {
                int current = num;
                int length = 1;

                while (numSet.find(current + 1) != numSet.end()) {
                    current++;
                    length++;
                }

                longest = max(longest, length);
            }
        }

        return longest;
    }
};

func longestConsecutive(nums []int) int {
    numSet := make(map[int]bool)

    for _, num := range nums {
        numSet[num] = true
    }

    longest := 0
    for num := range numSet {
        if !numSet[num-1] {
            current := num
            length := 1

            for numSet[current+1] {
                current++
                length++
            }

            if length > longest {
                longest = length
            }
        }
    }

    return longest
}

The linear time depends on starting only at run beginnings. Each number is visited at most twice: once when checking whether it is a run start, and once while its own run is being walked. The while loop never re-walks a run because only the first element of a run enters the loop. Space is

O(N)

for the set.

Hard Problems

7. LRU Cache

LeetCode 146 | Difficulty: Hard

Brief: design a cache with

O(1)

get and put that evicts the least recently used entry when full.

Why this pattern: the map alone cannot track order. A doubly linked list provides

O(1)

moves, and the map provides

O(1)

access to any node.

Key Insight: the head of the list is the most recently used entry and the tail is the least recently used. get and put both move a node to the head. When the cache is full, the tail node is removed from both the list and the map.

Visual:

    graph TD
    A["get(key)"] --> B{"key in map?"}
    B -->|No| C["return -1"]
    B -->|Yes| D["move node to head"]
    D --> E["return value"]
    F["put(key, value)"] --> G{"key in map?"}
    G -->|Yes| H["update value, move to head"]
    G -->|No| I{"at capacity?"}
    I -->|Yes| J["remove tail node and its map entry"]
    I -->|No| K["insert new node at head"]
    J --> K

Code:

class Node {
    constructor(key, value) {
        this.key = key;
        this.value = value;
        this.prev = null;
        this.next = null;
    }
}

class LRUCache {
    constructor(capacity) {
        this.capacity = capacity;
        this.cache = new Map();
        this.head = new Node(0, 0);
        this.tail = new Node(0, 0);
        // Dummy head and tail keep the list edges
        // from needing special cases on insert and remove.
        this.head.next = this.tail;
        this.tail.prev = this.head;
    }

    get(key) {
        if (!this.cache.has(key)) return -1;

        const node = this.cache.get(key);
        this._remove(node);
        this._addToHead(node);
        return node.value;
    }

    put(key, value) {
        if (this.cache.has(key)) {
            const node = this.cache.get(key);
            node.value = value;
            this._remove(node);
            this._addToHead(node);
        } else {
            if (this.cache.size >= this.capacity) {
                const tail = this._removeTail();
                // The map and the list must agree. Evicting
                // from the list without the map leaks the key.
                this.cache.delete(tail.key);
            }
            const node = new Node(key, value);
            this._addToHead(node);
            this.cache.set(key, node);
        }
    }

    _remove(node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    _addToHead(node) {
        node.prev = this.head;
        node.next = this.head.next;
        this.head.next.prev = node;
        this.head.next = node;
    }

    _removeTail() {
        const node = this.tail.prev;
        this._remove(node);
        return node;
    }
}

class Node:
    def __init__(self, key, value):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None


class LRUCache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = Node(0, 0)
        self.tail = Node(0, 0)
        # Dummy nodes mean insert and remove never
        # have to check whether the list is empty.
        self.head.next = self.tail
        self.tail.prev = self.head

    def _remove(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def _add_to_head(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def _remove_tail(self):
        node = self.tail.prev
        self._remove(node)
        return node

    def get(self, key):
        if key not in self.cache:
            return -1

        node = self.cache[key]
        self._remove(node)
        self._add_to_head(node)
        return node.value

    def put(self, key, value):
        if key in self.cache:
            node = self.cache[key]
            node.value = value
            self._remove(node)
            self._add_to_head(node)
        else:
            if len(self.cache) >= self.capacity:
                tail = self._remove_tail()
                del self.cache[tail.key]

            node = Node(key, value)
            self._add_to_head(node)
            self.cache[key] = node

class Node {
    int key, value;
    Node prev, next;

    public Node(int key, int value) {
        this.key = key;
        this.value = value;
    }
}

class LRUCache {
    private int capacity;
    private Map<Integer, Node> cache;
    private Node head, tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new HashMap<>();
        this.head = new Node(0, 0);
        this.tail = new Node(0, 0);
        this.head.next = this.tail;
        this.tail.prev = this.head;
    }

    public int get(int key) {
        if (!cache.containsKey(key)) return -1;

        Node node = cache.get(key);
        remove(node);
        addToHead(node);
        return node.value;
    }

    public void put(int key, int value) {
        if (cache.containsKey(key)) {
            Node node = cache.get(key);
            node.value = value;
            remove(node);
            addToHead(node);
        } else {
            if (cache.size() >= capacity) {
                Node tail = removeTail();
                cache.remove(tail.key);
            }
            Node node = new Node(key, value);
            addToHead(node);
            cache.put(key, node);
        }
    }

    private void remove(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void addToHead(Node node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

    private Node removeTail() {
        Node node = tail.prev;
        remove(node);
        return node;
    }
}

class Node {
public:
    int key, value;
    Node* prev;
    Node* next;

    Node(int k, int v) : key(k), value(v), prev(nullptr), next(nullptr) {}
};

class LRUCache {
private:
    int capacity;
    unordered_map<int, Node*> cache;
    Node* head;
    Node* tail;

    void remove(Node* node) {
        node->prev->next = node->next;
        node->next->prev = node->prev;
    }

    void addToHead(Node* node) {
        node->prev = head;
        node->next = head->next;
        head->next->prev = node;
        head->next = node;
    }

    Node* removeTail() {
        Node* node = tail->prev;
        remove(node);
        return node;
    }

public:
    LRUCache(int capacity) {
        this->capacity = capacity;
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head->next = tail;
        tail->prev = head;
    }

    int get(int key) {
        if (cache.find(key) == cache.end()) return -1;

        Node* node = cache[key];
        remove(node);
        addToHead(node);
        return node->value;
    }

    void put(int key, int value) {
        if (cache.find(key) != cache.end()) {
            Node* node = cache[key];
            node->value = value;
            remove(node);
            addToHead(node);
        } else {
            if (cache.size() >= capacity) {
                Node* tail = removeTail();
                cache.erase(tail->key);
                delete tail;
            }
            Node* node = new Node(key, value);
            addToHead(node);
            cache[key] = node;
        }
    }
};

type Node struct {
    key, value int
    prev, next *Node
}

type LRUCache struct {
    capacity int
    cache    map[int]*Node
    head     *Node
    tail     *Node
}

func Constructor(capacity int) LRUCache {
    lru := LRUCache{
        capacity: capacity,
        cache:    make(map[int]*Node),
        head:     &Node{},
        tail:     &Node{},
    }
    lru.head.next = lru.tail
    lru.tail.prev = lru.head
    return lru
}

func (this *LRUCache) remove(node *Node) {
    node.prev.next = node.next
    node.next.prev = node.prev
}

func (this *LRUCache) addToHead(node *Node) {
    node.prev = this.head
    node.next = this.head.next
    this.head.next.prev = node
    this.head.next = node
}

func (this *LRUCache) Get(key int) int {
    if node, exists := this.cache[key]; exists {
        this.remove(node)
        this.addToHead(node)
        return node.value
    }
    return -1
}

func (this *LRUCache) Put(key int, value int) {
    if node, exists := this.cache[key]; exists {
        node.value = value
        this.remove(node)
        this.addToHead(node)
    } else {
        if len(this.cache) >= this.capacity {
            tail := this.tail.prev
            this.remove(tail)
            delete(this.cache, tail.key)
        }
        node := &Node{key: key, value: value}
        this.addToHead(node)
        this.cache[key] = node
    }
}

class Node
    attr_accessor :key, :value, :prev, :next

    def initialize(key, value)
        @key = key
        @value = value
        @prev = nil
        @next = nil
    end
end

class LRUCache
    def initialize(capacity)
        @capacity = capacity
        @cache = {}
        @head = Node.new(0, 0)
        @tail = Node.new(0, 0)
        @head.next = @tail
        @tail.prev = @head
    end

    def get(key)
        return -1 unless @cache.key?(key)

        node = @cache[key]
        remove(node)
        add_to_head(node)
        node.value
    end

    def put(key, value)
        if @cache.key?(key)
            node = @cache[key]
            node.value = value
            remove(node)
            add_to_head(node)
        else
            if @cache.size >= @capacity
                tail = remove_tail
                @cache.delete(tail.key)
            end
            node = Node.new(key, value)
            add_to_head(node)
            @cache[key] = node
        end
    end

    private

    def remove(node)
        node.prev.next = node.next
        node.next.prev = node.prev
    end

    def add_to_head(node)
        node.prev = @head
        node.next = @head.next
        @head.next.prev = node
        @head.next = node
    end

    def remove_tail
        node = @tail.prev
        remove(node)
        node
    end
end

The invariant that holds everything together is that the map and the list always describe the same entries. When a node moves, no map change is needed, because the map points at the node rather than at a position. When a node is evicted, its map entry goes with it. get and put are each

O(1)

: one map lookup and a constant number of pointer updates.

Hard problems are where patterns separate candidates who pass from candidates who get offers. Track your misses and review them on a spaced schedule so you do not repeat them in the real interview.

These seven problems cover the full range of hash table work. Start with the membership check in Contains Duplicate, add the complement search in Two Sum, and build up to the combined structure in LRU Cache. By the end, you should recognize when a problem is asking for a set and when it needs a full map.

Done with these problems? The app has more, plus a spaced repetition system that brings problems back right before you would forget them. Continue your prep .