Chapter quiz · Hashing

Test what you learned.

8 questions on Hashing. Pass 70% to clear the chapter.

← Review chapter lessons

Quiz

Hashing — Chapter Quiz

Eight questions on Map vs Object, Set, WeakMap GC behavior, frequency counting, and LRU caching patterns.

0/ 9

Question 1
1
Which JavaScript data structure preserves insertion order AND allows any value (including objects) as a key?
APlain object {}BMapCSetDWeakMap
Map preserves insertion order and accepts any value as a key, including functions and objects. Plain objects coerce keys to strings and their order is partially spec-defined.
Question 2
2
What is the average-case time complexity of Map.get() and Map.set()?
AO(n)BO(log n)CO(1)DO(n log n)
Map uses a hash table internally. Average-case lookup and insertion are O(1). Worst-case (pathological hash collisions) is O(n) but effectively never occurs in practice.
Question 3
3
Why can't you iterate over a WeakMap or WeakSet?
AThey store values in sorted order, making iteration undefinedBKeys are held weakly, so the GC may remove entries at any time — a stable iteration snapshot is impossibleCThey only support string keysDIteration would cause memory leaks
Weak references don't prevent garbage collection. An entry's key can be collected between any two iterations, making a consistent traversal impossible. That's why the spec forbids iteration.
Question 4
4
What is the idiomatic way to count character frequencies in a string using a Map?
Amap.set(ch, map.get(ch) + 1) without a defaultBmap.set(ch, (map.get(ch) ?? 0) + 1) for each character chCmap[ch]++ using bracket notationDmap.add(ch) like a Set
map.get(ch) returns undefined for unseen characters. Using ?? 0 (nullish coalescing) safely initialises the count to zero before incrementing. Option A would produce NaN.
Question 5
5
An LRU (Least Recently Used) cache with O(1) get and put can be implemented in JS using:
AA plain object sorted by access timeBA Map — because it preserves insertion order — combined with delete-then-re-insert to move items to the endCA Set with a custom comparatorDA sorted array with binary search
Map iteration goes in insertion order. On a cache hit you delete the entry and re-insert it so it moves to the "most recent" end. The least-recently-used entry is always map.keys().next().value. Both operations are O(1).
Question 6
6
A plain JavaScript object {} is always a safe drop-in replacement for Map when the keys are strings.
TTrueFFalse
Plain objects inherit from Object.prototype, so keys like 'toString', 'constructor', or '__proto__' can shadow prototype properties, causing subtle bugs. Map has no prototype pollution issue.
Question 7
7
To find whether two strings are anagrams of each other, you can compare their ___ maps (a count of each character).
Build a frequency map for each string and compare all counts. If both maps are identical the strings are anagrams. This runs in O(n) time and O(k) space where k is the alphabet size.
Question 8
8
Which are legitimate use-cases for WeakMap? (Select all that apply)
Select all that apply.
AAttaching private data to a DOM node without preventing GC of the nodeBCaching computed results keyed by object identity, auto-cleared when the object is collectedCStoring a list of all active users with fast lookup by user objectDImplementing the private-class-field polyfill pattern
WeakMap is ideal when the lifetime of data should match the lifetime of the key object — DOM metadata, memoization caches, and private-field emulation. It is NOT suitable when you need to enumerate all entries (e.g., a list of all active users).