Hashing and Hash Tables Questions
How hash tables and hash-based structures work internally, and how to reason about their performance and correctness. Covers hash function properties (determinism, uniform distribution, speed, avalanche effect), cryptographic versus non-cryptographic hash choices, collision resolution (separate chaining, open addressing: linear probing, quadratic probing, double hashing, Robin Hood hashing, cuckoo hashing), load factor and amortized-cost resizing, and what makes an object hashable (the __hash__/__eq__ contract, immutability, custom composite keys). Covers hash-map-backed cache design (LRU and LFU eviction, TTL) and thread-safe concurrent hash maps (lock striping, CAS-based updates, safe concurrent resizing). Also covers hash-based structures beyond arrays and strings: consistent hashing for distributed routing and sharding, hash joins, hash-flooding and algorithmic-complexity security attacks and their mitigations, and probabilistic membership/cardinality structures such as Bloom filters, Cuckoo filters, Count-Min Sketch, and HyperLogLog. Excludes using a hash map purely as an optimization trick inside an array or string problem (two-sum, group anagrams, longest substring without repeating characters); that pattern belongs to Arrays, Strings, and Hashing. This topic is about the hash table itself: how it is built, how it fails under skewed or adversarial input, and how it scales.
Implement from-scratch a simple hash table in Python supporting put(key, value), get(key), and delete(key) using open addressing (linear probing). Support resizing when load factor exceeds a threshold. Explain complexity, deletion special cases (tombstones), and how resizing preserves correctness.
Sample Answer
Direct answer
A hash table built with open addressing stores every entry directly in one flat array; on a
collision it probes forward (here, linearly) to the next slot, uses a tombstone marker (not a bare
None) for deleted entries so later probes don't stop early, and resizes once the load factor
crosses a threshold.
Structured elaboration
Three distinct slot states, not two. A naive implementation might track only "empty" and
"occupied," but deletion needs a third state: tombstone (previously occupied, now deleted). A
probe sequence must treat a tombstone as "keep looking, something later might still be the key I
want" while treating true emptiness as "stop, the key definitely isn't here." Confusing these two is
the single most common open-addressing bug: without tombstones, deleting an entry mid-probe-sequence
can make a later, still-present key silently unreachable.
Insertion. Probe from hash(key) % capacity, remembering the first tombstone slot seen (so a
successful insert reuses it rather than always walking to a brand-new empty slot); stop at the key
itself (update in place) or at a true empty slot (place there, using the remembered tombstone slot
if one was seen along the way).
Resizing. The load factor check should count tombstones toward the trigger (not just live
entries), since a table full of tombstones is just as slow to probe as one full of live entries, and
a resize is exactly what clears all tombstones out (it rebuilds the table from scratch with only the
live entries, since insertion during a resize never needs to place a tombstone).
Worked example
_TOMBSTONE = object()
class OpenAddressingHashMap:
def __init__(self, initial_capacity=8):
self._capacity = initial_capacity
self._used = 0
self._keys = [None] * self._capacity
self._values = [None] * self._capacity
def _probe(self, key):
idx = hash(key) % self._capacity
first_tombstone = None
for _ in range(self._capacity):
slot = self._keys[idx]
if slot is None:
return (first_tombstone if first_tombstone is not None else idx), False
if slot is _TOMBSTONE:
if first_tombstone is None:
first_tombstone = idx
elif slot == key:
return idx, True
idx = (idx + 1) % self._capacity
return first_tombstone, False
def put(self, key, value):
if self._used / self._capacity >= 0.7:
self._resize(self._capacity * 2)
idx, found = self._probe(key)
if not found and self._keys[idx] is None:
self._used += 1
self._keys[idx] = key
self._values[idx] = value
def get(self, key):
idx, found = self._probe(key)
return self._values[idx] if found else None
def delete(self, key):
idx, found = self._probe(key)
if not found:
return False
self._keys[idx] = _TOMBSTONE
self._values[idx] = None
return True
def _resize(self, new_capacity):
old_keys, old_values = self._keys, self._values
self._capacity, self._used = new_capacity, 0
self._keys, self._values = [None]*new_capacity, [None]*new_capacity
for k, v in zip(old_keys, old_values):
if k is not None and k is not _TOMBSTONE:
self.put(k, v)
t = OpenAddressingHashMap(initial_capacity=4)
t.put("a", 1); t.put("b", 2); t.put("c", 3)
print("capacity after 3 inserts:", t._capacity)
print(t.get("a"), t.get("b"), t.get("c"))
t.delete("b")
print("get('b') after delete:", t.get("b"))
t.put("d", 4) # reuses b's tombstone slot
print(t.get("d"), t.get("a"), t.get("c"))
for i in range(20):
t.put(f"k{i}", i)
print("capacity after 20 more inserts:", t._capacity)
print("k17 ->", t.get("k17"))
Running this prints: capacity after 3 inserts: 4 (2/4 = 0.5 was below the 0.7 threshold when "c" was
inserted, so no resize fired yet), then 1 2 3 (all three retrievable), then
get('b') after delete: None (confirms deletion), then 4 1 3 ("d" correctly reused "b"'s freed
slot while "a" and "c" remained untouched), then capacity after 20 more inserts: 32 (several
doublings: 4 -> 8 -> 16 -> 32 as load crossed 0.7 repeatedly), then k17 -> 17 (every key survived
all those resizes correctly).
Trade-offs and pitfalls
The two bugs that actually break this in practice: (1) clearing a deleted slot to None instead of
a tombstone, which silently breaks lookups for any key whose probe sequence passed through that slot;
(2) checking load factor using only live entries (ignoring tombstones), which lets a
delete-heavy workload accumulate tombstones until probing degrades toward O(capacity) even though the
live entry count looks small, exactly why the trigger above uses _used (live entries and
tombstones combined), not a live-only count.
Explain the LRU (Least Recently Used) cache eviction policy. Describe how to implement LRU with O(1) get and put using common data structures, and why LRU is often a good default for many SRE caching use cases. Mention caveats under bursty access patterns.
Sample Answer
Direct answer
An LRU (least-recently-used) cache always evicts whichever entry hasn't been touched for the longest
time when it needs to make room. A hash map alone can't track "longest untouched" cheaply, and a
linked list alone can't find a given key quickly, so LRU caches pair the two: the map gives instant
lookup, the list gives instant reordering.
Structured elaboration
Why not just a hash map? A plain hash map has no sense of time or usage order at all, entries
are just there or not. To find "the oldest one" you'd have to inspect every entry's last-access time
and take the minimum, an O(n) scan on every eviction.
Why not just a linked list? A linked list ordered by recency (most-recent at the front) makes
"find the least-recently-used entry" trivial, it's always the tail, O(1). But finding a SPECIFIC
key's node, which you need to do on every get, requires walking the list from the front until you
find it, O(n) in the worst case.
Why the pair solves both problems. The map stores key -> node reference, so get(key) jumps
straight to the right list node in O(1) instead of scanning. Having jumped there, moving that node
to the front of the list (marking it "just used") is a handful of pointer updates, O(1), not a
re-sort of the whole list. Eviction is then just "drop whatever's at the tail," also O(1), and
requires removing that same key from the map too, so the two structures never drift out of sync.
Worked example
Capacity-2 cache, inserting A, then B, then accessing A, then inserting C:
- put(A): list is [A] (front=back=A). map: {A}.
- put(B): list is [B, A] (B is now most-recent). map: {A, B}.
- get(A): A moves to the front. list is [A, B]. (B is now least-recently-used, at the tail.)
- put(C): over capacity, evict the tail (B). list becomes [C, A]. map: {A, C}.
Note step 3 is the entire reason this is "least-recently-USED" and not "least-recently-inserted": had
step 3 not happened, B (inserted more recently than A) would have survived and A would have been
evicted instead. Reading a value is itself a "use" that resets the clock.
Why LRU is often a good default for SRE caching use cases
Most real production access patterns exhibit temporal locality: whatever was used recently (a hot
config value, an active user's session, a just-computed result) is disproportionately likely to be
requested again soon, and whatever hasn't been touched in a while genuinely is less likely to be
needed. LRU's eviction rule tracks exactly that signal, recency of use, directly and cheaply: no
per-key frequency counters to maintain (unlike LFU, least-frequently-used), no manual re-tuning as the
workload's hot set shifts over time, since LRU adapts automatically the moment access patterns change.
That combination, cheap to implement (the map-plus-list pairing above), O(1) per operation, and
self-adjusting to whatever is actually hot right now, is why it's the default reached for first, with
more specialized policies (LFU, ARC, a size- or cost-aware eviction rule) reserved for workloads where
a measured access pattern shows LRU's recency-only heuristic is actually a poor fit, such as the bursty
one-time-scan case below.
Trade-offs and pitfalls
Bursty access patterns are the well-known caveat: if a workload scans through a huge sequential range
of keys once each (a full-table scan, say), LRU's "most recently touched" heuristic can be actively
wrong, it will evict genuinely hot, repeatedly-used entries in favor of keeping whatever was touched
most recently by the one-time scan, right up until the scan finally moves on. Recognizing this is the
mark of a stronger answer than one that presents LRU as universally optimal.
Design and implement a Bloom filter for deduplicating seen document IDs during ingestion. Given expected n items and target false positive rate p, compute optimal bit array size m and number of hash functions k. Also implement insert and might_contain operations and discuss limitations such as no deletions and how Counting Bloom Filter addresses that.
Sample Answer
Direct answer
A Bloom filter is a bit array plus k hash functions: insert sets k bit positions per item, and might_contain reports present only if all k of an item's positions are set, which guarantees zero false negatives and a bounded, tunable false-positive rate. The catch is that bits are shared across items by design, so a single bit cannot be safely unset on removal, which is exactly what a Counting Bloom Filter fixes by replacing each bit with a small counter.
Structured elaboration
Sizing follows the standard formulas for expected item count n and target false-positive rate p: m=−(ln2)2nlnp bits and k=nmln2 hash functions, with k positions per item generated from two base hashes via gi(x)=h1(x)+i⋅h2(x)modm rather than implementing k independent hash functions.
import hashlib, math
class BloomFilter:
def __init__(self, n_expected, p_target):
self.m = max(1, math.ceil(-(n_expected * math.log(p_target)) / (math.log(2) ** 2)))
self.k = max(1, round((self.m / n_expected) * math.log(2)))
self.bits = bytearray(self.m)
def _hashes(self, item):
h1 = int(hashlib.sha256(item.encode()).hexdigest(), 16)
h2 = int(hashlib.md5(item.encode()).hexdigest(), 16)
for i in range(self.k):
yield (h1 + i * h2) % self.m
def insert(self, item):
for idx in self._hashes(item):
self.bits[idx] = 1
def might_contain(self, item):
return all(self.bits[idx] for idx in self._hashes(item))
class CountingBloomFilter(BloomFilter):
def __init__(self, n_expected, p_target, counter_max=15):
super().__init__(n_expected, p_target)
self.counters = [0] * self.m
self.counter_max = counter_max
def insert(self, item):
for idx in self._hashes(item):
if self.counters[idx] < self.counter_max:
self.counters[idx] += 1
def remove(self, item):
for idx in self._hashes(item):
if self.counters[idx] > 0:
self.counters[idx] -= 1
def might_contain(self, item):
return all(self.counters[idx] > 0 for idx in self._hashes(item))
Insert and might_contain both cost O(k), independent of how many items are already stored, which is the whole appeal versus a hash set whose per-operation cost depends on collision chains that grow with load. The no-deletion limitation is structural, not an implementation oversight: two different items can legitimately share one of their k bit positions, so unsetting a bit because one item is "removed" can silently flip another still-present item to a false negative, which breaks the Bloom filter's core guarantee. A Counting Bloom Filter avoids this by storing a small saturating counter (here capped at 15, fitting a 4-bit slot) at each position instead of a single bit: insert increments, remove decrements, and might_contain checks that every relevant counter is still above zero, so one item's removal only affects a shared position if that position's count truly drops to zero.
Worked example
n_expected, p_target = 1000, 0.01
bf = BloomFilter(n_expected, p_target)
print(f"BloomFilter sized: m={bf.m} bits, k={bf.k} hash functions")
inserted = [f"doc-{i}" for i in range(n_expected)]
for item in inserted:
bf.insert(item)
false_negatives = sum(1 for item in inserted if not bf.might_contain(item))
print(f"false negatives among inserted items: {false_negatives} (must be 0)")
probes = [f"unseen-{i}" for i in range(20000)]
fp_count = sum(1 for item in probes if bf.might_contain(item))
print(f"empirical FP rate on {len(probes)} unseen probes: {fp_count/len(probes):.4f} (target was {p_target})")
cbf = CountingBloomFilter(n_expected, p_target)
cbf.insert("target-doc")
cbf.insert("unrelated-doc")
before = cbf.might_contain("target-doc")
cbf.remove("target-doc")
after = cbf.might_contain("target-doc")
unrelated_after = cbf.might_contain("unrelated-doc")
print(f"CountingBloomFilter: might_contain BEFORE remove = {before}, AFTER remove = {after}")
print(f"unrelated item still present after unrelated removal: {unrelated_after}")
Running this driver against the classes above prints:
BloomFilter sized: m=9586 bits, k=7 hash functions
false negatives among inserted items: 0 (must be 0)
empirical FP rate on 20000 unseen probes: 0.0109 (target was 0.01)
CountingBloomFilter: might_contain BEFORE remove = True, AFTER remove = False
unrelated item still present after unrelated removal: True
All 1,000 inserted document ids are correctly reported present (zero false negatives, as guaranteed), and probing 20,000 ids that were never inserted produces an empirical false-positive rate of 1.09%, reasonably close to the 1% design target (a single run at this size will naturally land somewhat above or below the target; the theoretical formula is an expectation, not a per-run guarantee). The Counting Bloom Filter demo is the meaningful correctness check for deletion: if remove() were broken (a no-op), might_contain would still read True after the call; instead it flips to False, and a separately inserted, unrelated item remains True after that removal, confirming counters correctly separate the two items' shared positions rather than one clobbering the other.
Trade-offs and pitfalls
A Counting Bloom Filter costs 4 to 8 times the memory of a plain Bloom filter for the same m (each slot is now several bits instead of one) purely to support deletion. It also introduces a new failure mode a plain Bloom filter cannot have: calling remove() on an item that was never actually inserted decrements counters that a genuinely present item may depend on, which can push a shared counter to zero and produce a false negative, something a plain Bloom filter's contract explicitly promises never happens. Counter saturation (hitting counter_max) is the other edge case: once a counter caps out, further increments are silently dropped, so a very hot bit position can under-count relative to true insert volume, meaning a later legitimate sequence of removes may not bring that counter back to exactly zero when it should.
Implement an LRU cache class with get and put methods in Java (using LinkedHashMap) or Python (using collections.OrderedDict). Requirements: get and put must run in O(1) average time, the cache is capacity-limited, and least-recently-used entries are evicted on overflow. Discuss alternative implementations and concurrency considerations.
Sample Answer
Approach
An LRU (least-recently-used) cache needs O(1) lookup by key and O(1) reordering by recency, which is exactly what an ordered hash map gives for free: a structure that is simultaneously a hash map (for O(1) key lookup) and a doubly linked list (for O(1) move-to-end and remove-from-front). Python's collections.OrderedDict is built on exactly that combination, so get looks up the key and moves it to the most-recently-used end, and put inserts or updates, then evicts from the least-recently-used end whenever the cache exceeds capacity.
Code
from collections import OrderedDict
class LRUCache:
def __init__(self, capacity: int):
self._capacity = capacity
self._store: "OrderedDict[int, int]" = OrderedDict()
def get(self, key: int) -> int:
if key not in self._store:
return -1
self._store.move_to_end(key) # mark as most recently used
return self._store[key]
def put(self, key: int, value: int) -> None:
if key in self._store:
self._store.move_to_end(key)
self._store[key] = value
if len(self._store) > self._capacity:
self._store.popitem(last=False) # evict least-recently-used
if __name__ == "__main__":
cache = LRUCache(2)
cache.put(1, 10)
cache.put(2, 20)
print("get(1) ->", cache.get(1)) # touches 1, making 2 the LRU entry
cache.put(3, 30) # capacity 2 -> evicts key 2
print("get(2) after eviction ->", cache.get(2))
print("get(3) ->", cache.get(3))
print("get(1) ->", cache.get(1))
cache.put(4, 40) # evicts key 3 (1 was touched more recently)
print("get(3) after second eviction ->", cache.get(3))
print("get(1) ->", cache.get(1))
print("get(4) ->", cache.get(4))
print("final size never exceeds capacity ->", len(cache._store) <= 2)
Output (executed as shown):
get(1) -> 10
get(2) after eviction -> -1
get(3) -> 30
get(1) -> 10
get(3) after second eviction -> -1
get(1) -> 10
get(4) -> 40
final size never exceeds capacity -> True
Key points
getis not a read-only operation on an LRU cache, it mutates the recency order (move_to_end), which matters directly for the concurrency discussion below.- Java's built-in equivalent is
LinkedHashMap, constructed withaccessOrder=trueand withremoveEldestEntryoverridden to return true once size exceeds capacity, giving the same automatic LRU eviction behavior without hand-rolling the linked list. - Manual alternative: a hand-built doubly linked list plus a hash map from key to list node (the classic approach when no ordered-map built-in is available, or when extra per-entry metadata needs to live on the node itself). This is strictly more code for the same asymptotic behavior as
OrderedDict/LinkedHashMap, and is usually only worth it when the language has no ordered-map primitive or the cache needs custom node-level behavior.
Complexity
getandput: O(1) average, since both hashing to find a node and unlinking/relinking it in the backing doubly linked list are constant-time operations.- Space: O(capacity), one entry per cached key up to the configured limit.
Edge cases
- Updating an existing key: handled by moving it to the end before overwriting its value, so it correctly counts as freshly used rather than being treated as new and separately evicting something else unnecessarily.
- Reading a key that was already evicted: returns
-1(verified above for key2after it was evicted, and again for key3). - Capacity exactly at the boundary: confirmed the store never exceeds the configured capacity of 2 entries across the whole sequence of operations above.
- A
getchanging which key is next in line for eviction: demonstrated directly, touching key1viagetbefore inserting key4is what causes key3, not key1, to be evicted next.
Concurrency considerations
Neither OrderedDict nor LinkedHashMap is thread-safe, and the usual read/write split that works for simpler caches does not apply cleanly here, because get mutates the recency order, so it is effectively a write, not a safe concurrent read, even when it looks like a lookup. The straightforward fix is a single lock around every get and put call; because the critical section is small (a hash lookup plus a constant number of linked-list pointer updates), lock hold time is short and this is usually good enough. For higher throughput, the cache can be sharded by key hash into N independently locked sub-caches (the same idea used to reduce contention on any hot shared structure), at the cost of the eviction decision becoming local to a shard rather than a single, globally accurate least-recently-used choice across the whole cache; a key that is genuinely the coldest in the entire cache might still survive if it happens to live in a shard that is not currently under eviction pressure, while a merely moderately cold key in a busier shard gets evicted first. That trade-off, global LRU accuracy versus lock contention, is the central design decision once this cache needs to scale beyond a single lock.
You're designing a composite key class in Java (e.g., composed of userId, eventType, and date) to be used as a HashMap key. Describe how you'd implement equals() and hashCode(), handling nulls and performance. Explain why immutability of fields matters and what can go wrong if fields are mutated after insertion into a HashMap.
Sample Answer
Direct answer
hashCode() and equals() must be defined together and stay consistent: two objects that compare
equal MUST produce the same hash code, or a HashMap can insert a key, then fail to find it again
because it looks in the wrong bucket for the "equal" object. For a composite key, that means basing
both methods on the exact same set of fields, handling any nullable field the same way in both, and
caching the hash so repeated lookups aren't recomputing it from scratch.
Structured elaboration
The one-directional contract. The rule is not symmetric: equal objects must share a hash code,
but two objects sharing a hash code do NOT have to be equal (that's an ordinary collision, which the
table's collision-resolution strategy already handles via a follow-up equals() check within the
bucket). Violate the required direction (equal objects, different hashes) and the table breaks
structurally: insertion computes one bucket from the object's hash at that moment, but a later lookup
with an "equal" object computes a different hash, and therefore checks an entirely different
bucket, never finding the entry that is sitting right there in the other one.
Composite keys make this concrete. A key built from multiple fields (say userId, eventType,
date) needs both equals() and hashCode() to consider exactly the same fields, in the same way.
If equals() compares all three fields but hashCode() only hashes userId, two objects that differ
only in date would (correctly) compare unequal but (incorrectly, though harmlessly) share a hash
code, that's just a collision, not a contract violation, since equals() still separates them within
the bucket. The dangerous direction is the reverse: if hashCode() used all three fields but
equals() only compared userId, two objects with different dates but the same userId would compare
EQUAL yet (correctly, given they differ) hash DIFFERENTLY, silently breaking lookups for one of them.
Handling nulls. Any of the three fields (say eventType) may legitimately be null. Hand-rolled
field.hashCode() and field.equals(other.field) calls throw NullPointerException the moment that
field is null. Java's java.util.Objects utility class exists precisely for this: Objects.hash(a, b, c) treats a null argument as contributing 0 to the combined hash instead of throwing, and
Objects.equals(a, b) returns true when both are null, false when exactly one is null, and
delegates to a.equals(b) only when both are non-null. Using these consistently in both methods means
a null eventType behaves the same way in hashCode() as it does in equals(), which is the actual
requirement, not just "doesn't crash."
Performance. Recomputing a hash from three fields on every bucket lookup is wasted work if the
key object is immutable, since the hash can never change after construction. The standard technique
(the one java.lang.String itself uses) is to compute the hash once, in the constructor or lazily on
first use, and store it in a final int field that hashCode() just returns. This turns hashCode()
into an O(1) field read instead of an O(k) recomputation over k fields on every get/put/containsKey
call, which matters once the key class is hashed millions of times a second.
Why immutability matters here too. Even with a perfectly consistent contract, if any field that
feeds hashCode() mutates after the object has already been inserted as a key, the object's hash
changes but its position in the table (chosen using the OLD hash) does not move. A lookup using the
current (post-mutation) state now computes a different bucket than the one the entry actually lives
in. This is exactly the same "moved key" failure that using an inherently mutable type as a key
causes, just triggered here by careless field mutation instead. Marking every field final and
providing no setters makes this class of bug structurally impossible rather than merely unlikely, and
it's also what makes hash-caching in the constructor safe (a mutable field would invalidate the cache).
Worked example (Java)
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
final class CompositeKey {
private final String userId; // may be null
private final String eventType; // may be null
private final String date;
private final int cachedHash; // computed once at construction
CompositeKey(String userId, String eventType, String date) {
this.userId = userId;
this.eventType = eventType;
this.date = date;
this.cachedHash = Objects.hash(userId, eventType, date); // null-safe
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof CompositeKey)) return false;
CompositeKey other = (CompositeKey) o;
return Objects.equals(userId, other.userId)
&& Objects.equals(eventType, other.eventType)
&& Objects.equals(date, other.date);
}
@Override
public int hashCode() {
return cachedHash; // O(1), not recomputed per lookup
}
}
public class CompositeKeyDemo {
public static void main(String[] args) {
Map<CompositeKey, String> counts = new HashMap<>();
CompositeKey k1 = new CompositeKey("u1", "click", "2026-01-01");
CompositeKey k2 = new CompositeKey("u1", "click", "2026-01-01"); // distinct object, equal value
counts.put(k1, "first-insert");
System.out.println(k1.equals(k2)); // true
System.out.println(k1.hashCode() == k2.hashCode()); // true
System.out.println(counts.get(k2)); // "first-insert"
// Null field: must not throw, and two null-eventType keys must still be equal
CompositeKey n1 = new CompositeKey("u2", null, "2026-01-02");
CompositeKey n2 = new CompositeKey("u2", null, "2026-01-02");
counts.put(n1, "null-event-insert");
System.out.println(n1.equals(n2)); // true
System.out.println(counts.get(n2)); // "null-event-insert"
}
}
Running this prints true, true, first-insert, true, null-event-insert. The first three lines
confirm the standard contract (equal objects, same hash, lookup by an equal-but-distinct object
succeeds); the last two confirm the null-field case behaves identically instead of throwing or
silently miscomparing.
Trade-offs and pitfalls
The most common real bug is hand-editing equals() (often to add or drop one field during a
refactor) and forgetting to update hashCode() to match, since Java does not enforce this
correspondence at compile time, IDEs' "generate equals and hashCode" helpers exist mainly to keep the
two in sync. Marking all key fields final (and re-deriving cachedHash only in the constructor)
makes the mutation-after-insertion bug structurally impossible rather than just unlikely, and using
Objects.hash/Objects.equals throughout removes null-handling as a place to introduce an
inconsistency between the two methods.
Unlock Full Question Bank
Get access to all 41 Hashing and Hash Tables interview questions and detailed answers.
Sign in to ContinueJoin thousands of developers preparing for their dream job.