Hash Table: Code Templates in 6 Languages

Coding Patterns - Guide to 30 Core Algorithm Patterns

Hash Table Pattern: Complete Guide with Examples

If you have not read the concept guide yet, start there for the intuition and the complexity analysis. This page gives you the code to memorize. Each template covers the same logic in JavaScript, Python, Java, C++, Go, and Ruby. All of them run in

O(N)

time and use

O(N)

space for the map.

Main Template: Frequency Counter

Count the occurrences of each element in a collection. This is the foundation for most other hash table work, from anagram checks to top-k frequency problems.

Use this for Ransom Note and as the first half of Intersection of Two Arrays II.

function frequencyCounter(arr) {
    const freq = new Map();

    for (const item of arr) {
        // Read the existing count, default to 0 for a new key,
        // then write back the incremented value in one step.
        freq.set(item, (freq.get(item) || 0) + 1);
    }

    return freq;
}

def frequency_counter(arr):
    freq = {}

    for item in arr:
        # get with a default avoids a KeyError on the first
        # occurrence. After that, the existing count is read
        # and incremented in the same expression.
        freq[item] = freq.get(item, 0) + 1

    return freq

import java.util.HashMap;
import java.util.Map;

Map<Integer, Integer> frequencyCounter(int[] arr) {
    Map<Integer, Integer> freq = new HashMap<>();

    for (int num : arr) {
        // getOrDefault handles the first occurrence,
        // where no count exists yet.
        freq.put(num, freq.getOrDefault(num, 0) + 1);
    }

    return freq;
}

#include <unordered_map>
#include <vector>

unordered_map<int, int> frequencyCounter(const vector<int>& arr) {
    unordered_map<int, int> freq;

    for (int num : arr) {
        // operator[] inserts a zero for a new key,
        // so incrementing handles both cases.
        freq[num]++;
    }

    return freq;
}

func frequencyCounter(arr []int) map[int]int {
    freq := make(map[int]int)

    for _, num := range arr {
        // A missing key reads as 0, so the first
        // occurrence increments from 0 to 1.
        freq[num]++
    }

    return freq
}

Templates only help if you can recall them without staring at the screen. Turn these snippets into flashcards for daily mobile review.

Code Breakdown

Key Variables

freq / counts: the map that holds one count per unique element.
item / num: the current element being processed.
count: the number of times the element has appeared so far.

Visual Mechanism

    graph TD
    A["Empty map"] --> B["Read next element"]
    B --> C{"Is it already a key?"}
    C -->|No| D["Insert with count 1"]
    C -->|Yes| E["Add 1 to its count"]
    D --> F["More elements?"]
    E --> F
    F -->|Yes| B
    F -->|No| G["Return the map"]

Critical Sections

The initialization creates the empty map, and the default value matters. Ruby uses Hash.new(0), C++ operator[] inserts a zero for new keys, Java uses getOrDefault, and Python reads with get(item, 0). All of these make the first occurrence of an element count as 1 instead of crashing or counting as 0.

The update step reads the current count, adds 1, and writes it back. In most languages the read and the write happen in the same expression, which is easy to misread under time pressure. Practice reading it as “read, increment, write.”

The loop visits each element exactly once. Nothing else is needed, and the iteration order of the map never matters for counting.

Variations

1. Complement Search

Use this when two elements must satisfy a relation, like two numbers summing to a target. For each element, check whether the element that would complete the pair has been seen, then store the current element.

Time

O(N)

, Space

O(N)

Use this for Two Sum .

function complementSearch(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 [];
}

def complement_search(nums, target):
    seen = {}

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

        # The check runs before the store. Storing first
        # lets an element pair with itself.
        if complement in seen:
            return [seen[complement], i]

        seen[num] = i

    return []

import java.util.HashMap;
import java.util.Map;

int[] complementSearch(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[]{};
}

#include <unordered_map>
#include <vector>

vector<int> complementSearch(const 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 {};
}

func complementSearch(nums []int, target int) []int {
    seen := make(map[int]int)

    for i, num := range nums {
        complement := target - num

        if idx, exists := seen[complement]; exists {
            return []int{idx, i}
        }

        seen[num] = i
    }

    return []int{}
}

def complement_search(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

2. Grouping Pattern

Use this when elements share a canonical form, like anagrams sharing sorted letters. The canonical form becomes the key, and each key collects a list.

Time

O(N)

plus the cost of building each key, Space

O(N)

Use this for Group Anagrams .

function groupByKey(arr, keyFunction) {
    const groups = new Map();

    for (const item of arr) {
        const key = keyFunction(item);

        // Insert an empty list on first sight of a key,
        // then append. The list must exist before the push.
        if (!groups.has(key)) {
            groups.set(key, []);
        }
        groups.get(key).push(item);
    }

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

def group_by_key(arr, key_function):
    groups = {}

    for item in arr:
        key = key_function(item)

        # setdefault inserts an empty list only when
        # the key is missing, then returns the list
        # that ends up under the key.
        groups.setdefault(key, []).append(item)

    return list(groups.values())

import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.function.Function;

Map<String, List<String>> groupByKey(String[] arr, Function<String, String> keyFunction) {
    Map<String, List<String>> groups = new HashMap<>();

    for (String item : arr) {
        String key = keyFunction.apply(item);

        // computeIfAbsent creates the list once,
        // on the first occurrence of the key.
        groups.computeIfAbsent(key, k -> new ArrayList<>()).add(item);
    }

    return groups;
}

#include <unordered_map>
#include <vector>
#include <string>
#include <algorithm>

unordered_map<string, vector<string>> groupByKey(const vector<string>& arr) {
    unordered_map<string, vector<string>> groups;

    for (const string& item : arr) {
        string key = item;
        sort(key.begin(), key.end());

        // operator[] creates the vector if the key
        // is new, so append always has a target.
        groups[key].push_back(item);
    }

    return groups;
}

func groupByKey(arr []string, keyOf func(string) string) map[string][]string {
    groups := make(map[string][]string)

    for _, item := range arr {
        key := keyOf(item)

        // A missing key reads as nil, and appending
        // to nil creates the slice, so no existence
        // check is needed.
        groups[key] = append(groups[key], item)
    }

    return groups
}

def group_by_key(arr, key_function)
    # The block runs only when a key is read for the
    # first time, which creates its empty list.
    groups = Hash.new { |h, k| h[k] = [] }

    arr.each do |item|
        groups[key_function.call(item)] << item
    end

    groups
end

3. Count-Down Comparison

Use this when one collection must be built from another, like a ransom note from a magazine. Count the source collection, then decrement counts while consuming the target.

Time

O(N)

, Space

O(N)

function canBeBuilt(target, source) {
    const counts = new Map();

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

    for (const ch of target) {
        // A missing key or an exhausted count means
        // the source cannot supply this character.
        if (!counts.has(ch) || counts.get(ch) === 0) {
            return false;
        }
        counts.set(ch, counts.get(ch) - 1);
    }

    return true;
}

def can_be_built(target, source):
    counts = {}

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

    for ch in target:
        # get with a default of 0 treats a missing
        # letter as already exhausted, which fails.
        if counts.get(ch, 0) == 0:
            return False
        counts[ch] -= 1

    return True

import java.util.HashMap;
import java.util.Map;

boolean canBeBuilt(String target, String source) {
    Map<Character, Integer> counts = new HashMap<>();

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

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

    return true;
}

#include <unordered_map>
#include <string>

bool canBeBuilt(const string& target, const string& source) {
    unordered_map<char, int> counts;

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

    for (char c : target) {
        // operator[] reads 0 for a missing letter,
        // which correctly fails the check.
        if (counts[c] == 0) {
            return false;
        }
        counts[c]--;
    }

    return true;
}

Each variation above is a separate review card in the app. Drill them individually so you do not mix up the conditions under pressure.

Now head to the practice problems to apply these templates to real interview questions.

Now that you have the templates, the next step is application. Head to the practice problems or start reviewing these templates with spaced repetition .