dsa2 min read
Minimum Window Substring [Hard] — Sliding Window with Frequency Map
Find the minimum window in s that contains all characters of t using a shrinkable sliding window with a character frequency counter.
Read →
Hash-map
61 articles
dsa1 min read
Max Points on a Line [Hard] — Slope HashMap
Find the maximum number of points on the same line using a slope-as-fraction HashMap for each anchor point.
Read →
dsa1 min read
Subarrays with K Different Integers [Hard] — Sliding Window Subtract
Count subarrays with exactly K distinct integers using the formula: atMost(K) - atMost(K-1).
Read →
dsa2 min read
Maximum Frequency Stack [Hard] — Frequency + Group Stacks
Design a stack that pops the most frequent element (breaking ties by recency) using frequency and group-stacks mapping.
Read →
dsa5 min read
Hashing & Maps — Complete Guide (Problems 161–205)
Master HashMap, HashSet, and cache design patterns with 45 problems, 5-language solutions, and MAANG company tags.
Read →
dsa2 min read
Two Sum [Easy] — HashMap Complement Lookup
Find two indices that add to target in O(n) by storing each number in a HashMap and looking up the complement.
Read →
dsa2 min read
Valid Anagram [Easy] — Frequency Counter
Check if two strings are anagrams by comparing their character frequency counts using an array or HashMap.
Read →
dsa1 min read
Ransom Note [Easy] — Frequency Map Check
Check if a ransom note can be constructed from magazine letters using a character frequency map.
Read →
dsa2 min read
Isomorphic Strings [Easy] — Two-Way Character Mapping
Check if two strings are isomorphic by maintaining bidirectional character mappings to ensure a consistent one-to-one correspondence.
Read →
dsa1 min read
Word Pattern [Easy] — Bijective Two-Way Map
Check if a string follows a given pattern using bidirectional mapping between pattern chars and words.
Read →
dsa2 min read
Happy Number [Easy] — HashSet Cycle Detection
Determine if a number is happy by repeatedly summing digit squares and detecting cycles using a HashSet or Floyd algorithm.
Read →
dsa1 min read
Contains Duplicate II [Easy] — Index Window HashMap
Find if any two duplicate elements are within k indices of each other using a HashMap of last-seen positions.
Read →
dsa1 min read
Find Common Characters [Easy] — Min Frequency Intersection
Find characters common to all strings in a list by intersecting their frequency arrays with element-wise minimum.
Read →
dsa1 min read
Jewels and Stones [Easy] — HashSet Membership
Count how many stones are jewels by storing jewel types in a HashSet and checking each stone.
Read →
dsa1 min read
Find Duplicate File in System [Medium] — Content HashMap
Find all groups of duplicate files by parsing path strings and grouping files by their content using a HashMap.
Read →
dsa1 min read
Group Anagrams [Medium] — Sorted Key HashMap
Group strings that are anagrams together by using their sorted form as a HashMap key.
Read →
dsa2 min read
Top K Frequent Elements [Medium] — Bucket Sort O(n)
Find the k most frequent elements in O(n) using bucket sort by frequency instead of a heap.
Read →
dsa2 min read
LRU Cache [Medium] — Doubly Linked List + HashMap
Design a Least Recently Used cache with O(1) get and put operations using a HashMap combined with a doubly linked list.
Read →
dsa1 min read
Subarray Sum Equals K [Medium] — Prefix Sum HashMap
Count subarrays with sum exactly k using prefix sums stored in a HashMap to find valid starting positions in O(n).
Read →
dsa1 min read
Continuous Subarray Sum [Medium] — Prefix Modulo Map
Check if a continuous subarray of length >= 2 sums to a multiple of k using prefix sum modulo k with a HashMap.
Read →
dsa1 min read
Longest Consecutive Sequence [Medium] — HashSet O(n)
Find the longest consecutive integer sequence in O(n) by using a HashSet and only starting sequences from their minimum element.
Read →
dsa2 min read
Insert Delete GetRandom O(1) [Medium] — Array + HashMap Design
Design a set with O(1) insert, delete, and getRandom using a dynamic array combined with a HashMap for index tracking.
Read →
dsa2 min read
Find All Anagrams in a String [Medium] — Fixed Window + Freq Match
Find all starting indices of anagram substrings by using a fixed window with character frequency comparison.
Read →
dsa1 min read
Random Pick with Weight [Medium] — Prefix Sum + Binary Search
Implement weighted random selection by building a prefix sum array and using binary search to find the sampled index.
Read →
dsa1 min read
Brick Wall [Medium] — Gap Position Frequency Map
Find the vertical line that crosses the fewest bricks by counting the most frequent gap position using a HashMap.
Read →
dsa2 min read
Unique Number of Occurrences — Frequency Map Validation
Check if all value frequencies are unique using two hash sets in O(n).
Read →
dsa2 min read
Count Wonderful Substrings — Bitmask + Prefix XOR Map
Count substrings with at most one odd-frequency letter using bitmask prefix XOR and a hash map.
Read →
dsa2 min read
Equal Row and Column Pairs — Hash Tuple Rows and Columns
Count (row, col) pairs that are equal by hashing each row tuple and each column tuple.
Read →
dsa2 min read
Two Sum IV - BST — Hash Set + In-Order Traversal
Find if a BST contains two nodes summing to target using a hash set during DFS traversal.
Read →
dsa2 min read
Longest Arithmetic Subsequence — DP + Hash Map per Index
Find the longest arithmetic subsequence using dp[i][diff] = length ending at index i with given difference.
Read →
dsa2 min read
Count Bad Pairs — Complement Counting with HashMap
Count pairs (i,j) where j-i != nums[j]-nums[i] by counting good pairs via frequency map of nums[i]-i.
Read →
dsa2 min read
Make Sum Divisible by P — Prefix Mod + HashMap
Find the smallest subarray to remove so the remaining sum is divisible by p using prefix modular arithmetic.
Read →
dsa2 min read
Tuple with Same Product — Product Frequency Map
Count tuples (a,b,c,d) where a*b=c*d by counting pairs with each product using a frequency map.
Read →
dsa2 min read
Encode and Decode TinyURL — HashMap Bidirectional Mapping
Design a URL shortener using two hash maps for O(1) encode and decode operations.
Read →
dsa2 min read
Fraction to Recurring Decimal — Remainder Tracking HashMap
Convert a fraction to decimal string with recurring part detected via remainder position tracking.
Read →
dsa1 min read
Find Duplicate Subtrees — Serialize + HashMap
Find all duplicate subtrees by serializing each subtree and tracking serialization counts in a hash map.
Read →
dsa2 min read
Design HashMap — Chaining with Linked Lists
Implement a hash map from scratch using an array of buckets with chaining for collision resolution.
Read →
dsa2 min read
Design HashSet — Bit Array or Chaining Approach
Implement a hash set from scratch supporting add, remove, and contains in O(1) average time.
Read →
dsa2 min read
Random Pick Index — Reservoir Sampling
Pick a random index of a target value with equal probability using reservoir sampling over the array.
Read →
dsa1 min read
Most Common Word — Normalize + Frequency Map
Find the most common word not in a banned list by normalizing input and using a frequency counter.
Read →
dsa2 min read
Hand of Straights — Greedy with Ordered Frequency Map
Determine if cards can be rearranged into consecutive groups of size groupSize using a sorted frequency map.
Read →
dsa1 min read
Subarray Sum Divisible by K — Prefix Mod HashMap
Count subarrays with sum divisible by k using prefix mod frequencies and the complement map pattern.
Read →
dsa2 min read
Count Good Meals — Power-of-Two Complement HashMap
Count pairs summing to a power of 2 by checking all 22 powers-of-2 against a running frequency map.
Read →
dsa2 min read
Time Based Key-Value Store — HashMap + Binary Search
Design a time-stamped key-value store supporting set and get(key, timestamp) using binary search on sorted timestamps.
Read →
dsa2 min read
4Sum II — Two-Map Split and Match
Count 4-tuples summing to zero by splitting into two pairs and using a frequency map of pair sums.
Read →
dsa2 min read
LFU Cache — HashMap + Frequency Buckets + DLL
Implement an LFU cache with O(1) get/put using three hash maps: key→val, key→freq, freq→OrderedDict.
Read →
dsa2 min read
All O'one Data Structure — DLL of Buckets + HashMap
Design a data structure supporting inc/dec and getMaxKey/getMinKey in O(1) using a doubly linked list of frequency buckets.
Read →
dsa2 min read
Design Twitter — HashMap + Heap for News Feed
Design Twitter with follow/unfollow and getNewsFeed using per-user tweet lists and a min-heap merge.
Read →
dsa2 min read
Palindrome Pairs — HashMap + Palindrome Check
Find all index pairs forming palindromes by checking prefix/suffix splits against a reverse-word map.
Read →
dsa5 min read
Hashing & Maps Master Recap — All Patterns & Templates
Complete cheatsheet for Hashing & Maps: all 7 patterns, Big O reference, template code, and MAANG priority guide.
Read →
dsa2 min read
Copy List with Random Pointer — HashMap or Interleave
Deep copy a linked list with random pointers using either a hash map or the O(1) space interleave technique.
Read →
dsa1 min read
Remove Zero Sum Consecutive Nodes — Prefix Sum Map
Remove consecutive nodes that sum to zero by tracking prefix sums in a map and relinking past zero-sum runs.
Read →
dsa1 min read
Next Greater Element I — Monotonic Stack with HashMap
Find the next greater element for each query in O(n+m) using a monotonic stack on nums2 and a lookup map.
Read →
dsa1 min read
Path Sum III — Prefix Sum HashMap on Tree
Count paths in a binary tree summing to target (not necessarily root-to-leaf) using a prefix sum frequency map.
Read →
dsa2 min read
Fruit Into Baskets [Medium] — Longest Subarray with 2 Distinct
Find the maximum fruits you can collect starting from any tree with two baskets (at most 2 distinct fruit types) using a sliding window.
Read →
dsa1 min read
4Sum II [Medium] — Split and Hash
Count tuples (i,j,k,l) where nums1[i]+nums2[j]+nums3[k]+nums4[l]=0 by hashing all pairs from first two arrays.
Read →
dsa1 min read
Subarrays with K Different Integers [Hard] — atMost(K)−atMost(K−1)
Count subarrays with exactly K distinct integers using the mathematical trick: exactly(K) = atMost(K) - atMost(K-1).
Read →
dsa1 min read
Subarray Sum Divisible by K [Medium] — Prefix Sum Modulo
Count subarrays with sum divisible by k using prefix sum modulo k and a frequency map of remainders.
Read →
dsa2 min read
Substring with Concatenation of All Words [Hard] — Multi-Start Window
Find all starting indices of substrings that are concatenations of all given words using a sliding window for each possible word-aligned start.
Read →
dsa1 min read
Minimum Consecutive Cards to Pick Up [Medium] — HashMap Window
Find the minimum number of consecutive cards that contain a matching pair using a HashMap tracking last seen positions.
Read →
dsa1 min read
Longest Substring with At Most Two Distinct Characters [Hard]
Find the longest substring containing at most 2 distinct characters using a variable sliding window with a character count map.
Read →