Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Build confidence with an intuition-first walkthrough focused on array fundamentals.
Design a HashMap without using any built-in hash table libraries.
Implement the MyHashMap class:
MyHashMap() initializes the object with an empty map.void put(int key, int value) inserts a (key, value) pair into the HashMap. If the key already exists in the map, update the corresponding value.int get(int key) returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key.void remove(key) removes the key and its corresponding value if the map contains the mapping for the key.Example 1:
Input ["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"] [[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]] Output [null, null, null, 1, -1, null, 1, null, -1] Explanation MyHashMap myHashMap = new MyHashMap(); myHashMap.put(1, 1); // The map is now [[1,1]] myHashMap.put(2, 2); // The map is now [[1,1], [2,2]] myHashMap.get(1); // return 1, The map is now [[1,1], [2,2]] myHashMap.get(3); // return -1 (i.e., not found), The map is now [[1,1], [2,2]] myHashMap.put(2, 1); // The map is now [[1,1], [2,1]] (i.e., update the existing value) myHashMap.get(2); // return 1, The map is now [[1,1], [2,1]] myHashMap.remove(2); // remove the mapping for 2, The map is now [[1,1]] myHashMap.get(2); // return -1 (i.e., not found), The map is now [[1,1]]
Constraints:
0 <= key, value <= 106104 calls will be made to put, get, and remove.Problem summary: Design a HashMap without using any built-in hash table libraries. Implement the MyHashMap class: MyHashMap() initializes the object with an empty map. void put(int key, int value) inserts a (key, value) pair into the HashMap. If the key already exists in the map, update the corresponding value. int get(int key) returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key. void remove(key) removes the key and its corresponding value if the map contains the mapping for the key.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Array · Hash Map · Linked List · Design
["MyHashMap","put","put","get","get","put","get","remove","get"] [[],[1,1],[2,2],[1],[3],[2,1],[2],[2],[2]]
design-hashset)design-skiplist)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #706: Design HashMap
class MyHashMap {
private int[] data = new int[1000001];
public MyHashMap() {
Arrays.fill(data, -1);
}
public void put(int key, int value) {
data[key] = value;
}
public int get(int key) {
return data[key];
}
public void remove(int key) {
data[key] = -1;
}
}
/**
* Your MyHashMap object will be instantiated and called as such:
* MyHashMap obj = new MyHashMap();
* obj.put(key,value);
* int param_2 = obj.get(key);
* obj.remove(key);
*/
// Accepted solution for LeetCode #706: Design HashMap
type MyHashMap struct {
data []int
}
func Constructor() MyHashMap {
data := make([]int, 1000010)
for i := range data {
data[i] = -1
}
return MyHashMap{data}
}
func (this *MyHashMap) Put(key int, value int) {
this.data[key] = value
}
func (this *MyHashMap) Get(key int) int {
return this.data[key]
}
func (this *MyHashMap) Remove(key int) {
this.data[key] = -1
}
/**
* Your MyHashMap object will be instantiated and called as such:
* obj := Constructor();
* obj.Put(key,value);
* param_2 := obj.Get(key);
* obj.Remove(key);
*/
# Accepted solution for LeetCode #706: Design HashMap
class MyHashMap:
def __init__(self):
self.data = [-1] * 1000001
def put(self, key: int, value: int) -> None:
self.data[key] = value
def get(self, key: int) -> int:
return self.data[key]
def remove(self, key: int) -> None:
self.data[key] = -1
# Your MyHashMap object will be instantiated and called as such:
# obj = MyHashMap()
# obj.put(key,value)
# param_2 = obj.get(key)
# obj.remove(key)
// Accepted solution for LeetCode #706: Design HashMap
struct MyHashMap {
buckets: Vec<Vec<(i32,i32)>>,
}
// Prime number of buckets to reduce collisions
const N_BUCKETS: usize = 1031;
impl MyHashMap {
fn new() -> Self {
Self{ buckets: vec![vec![]; N_BUCKETS] }
}
fn hash(key: i32) -> usize {
key as usize % N_BUCKETS
}
fn find_entry(&mut self, key: i32) -> (&mut Vec<(i32, i32)>, Result<usize, usize>) {
let bucket = &mut self.buckets[Self::hash(key)];
let result = bucket.binary_search_by(|(k, v)| k.cmp(&key));
(bucket, result)
}
fn put(&mut self, key: i32, value: i32) {
match self.find_entry(key) {
(bucket, Ok(index)) => bucket[index] = (key, value),
(bucket, Err(index)) => bucket.insert(index, (key, value)),
}
}
fn get(&self, key: i32) -> i32 {
let bucket = &self.buckets[Self::hash(key)];
match bucket.binary_search_by(|(k, v)| k.cmp(&key)) {
Ok(index) => bucket[index].1,
Err(index) => -1,
}
}
fn remove(&mut self, key: i32) {
match self.find_entry(key) {
(bucket, Ok(index)) => { bucket.remove(index); },
_ => (),
}
}
}
// Accepted solution for LeetCode #706: Design HashMap
class MyHashMap {
data: Array<number>;
constructor() {
this.data = new Array(10 ** 6 + 1).fill(-1);
}
put(key: number, value: number): void {
this.data[key] = value;
}
get(key: number): number {
return this.data[key];
}
remove(key: number): void {
this.data[key] = -1;
}
}
/**
* Your MyHashMap object will be instantiated and called as such:
* var obj = new MyHashMap()
* obj.put(key,value)
* var param_2 = obj.get(key)
* obj.remove(key)
*/
Use this to step through a reusable interview workflow for this problem.
Copy all n nodes into an array (O(n) time and space), then use array indexing for random access. Operations like reversal or middle-finding become trivial with indices, but the O(n) extra space defeats the purpose of using a linked list.
Most linked list operations traverse the list once (O(n)) and re-wire pointers in-place (O(1) extra space). The brute force often copies nodes to an array to enable random access, costing O(n) space. In-place pointer manipulation eliminates that.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Wrong move: Zero-count keys stay in map and break distinct/count constraints.
Usually fails on: Window/map size checks are consistently off by one.
Fix: Delete keys when count reaches zero.
Wrong move: Pointer updates overwrite references before they are saved.
Usually fails on: List becomes disconnected mid-operation.
Fix: Store next pointers first and use a dummy head for safer joins.