Why Hash Map Exists and What Problem It Solves in DSA Typescript - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why do we use a hash map instead of a list for key-value storage?

Imagine you want to store and quickly find phone numbers by name. You can use a list of pairs or a hash map. Why is a hash map better for this?

A Because hash maps allow faster search by key, usually in constant time, while lists require checking each item one by one.

B Because lists use less memory than hash maps, making them faster for large data.

C Because hash maps store data in order, making it easier to print sorted results.

D Because lists automatically prevent duplicate keys, while hash maps do not.

💡 Hint

Think about how long it takes to find a phone number in a list versus a hash map.

Hash maps use a special function to jump directly to the data location, making search very fast. Lists require checking each element until the key is found, which is slower.

❓ Predict Output

intermediate

What is the output after inserting keys in a hash map?

Consider this TypeScript code using a hash map (object) to store ages by name. What is printed?

DSA Typescript

const ages: {[key: string]: number} = {};
ages['Alice'] = 30;
ages['Bob'] = 25;
ages['Alice'] = 35;
console.log(ages['Alice']);

A 35

B 30

C 25

D undefined

💡 Hint

What happens when you assign a value to the same key twice?

Assigning a new value to an existing key in a hash map updates the value. So 'Alice' age changes from 30 to 35.

🔧 Debug

advanced

Why does this hash map lookup return undefined?

Look at this TypeScript code. Why does accessing ages['Charlie'] return undefined?

DSA Typescript

const ages: {[key: string]: number} = { 'Alice': 30, 'Bob': 25 };
console.log(ages['Charlie']);

A Because TypeScript does not allow string keys in objects.

B Because the hash map keys are case sensitive and 'Charlie' is misspelled.

C Because the hash map is empty and has no keys.

D Because 'Charlie' key does not exist in the hash map, so it returns undefined.

💡 Hint

Check if the key you are looking for is present in the hash map.

Accessing a key that does not exist in a hash map returns undefined in JavaScript/TypeScript.

❓ Predict Output

advanced

What is the output after deleting a key from a hash map?

Given this TypeScript code, what is printed after deleting a key?

DSA Typescript

const map: {[key: string]: number} = { 'x': 10, 'y': 20 };
delete map['x'];
console.log(map);

A {"x":null,"y":20}

B {"y":20}

C {"x":10,"y":20}

D SyntaxError

💡 Hint

What does the delete operator do to a key in an object?

The delete operator removes the key and its value from the object, so only 'y' remains.

🧠 Conceptual

expert

What problem does a hash map solve compared to arrays for large datasets?

When working with large datasets, why is a hash map preferred over arrays for key-based data retrieval?

A Because arrays automatically sort data, making hash maps unnecessary for ordered data.

B Because hash maps use less memory than arrays for storing the same data.

C Because hash maps provide average constant time complexity O(1) for search, insert, and delete operations, while arrays require linear time O(n) for search by value.

D Because arrays cannot store key-value pairs, only hash maps can.

💡 Hint

Think about how long it takes to find an item by key in an array versus a hash map.

Hash maps use a hashing function to jump directly to the data location, making operations very fast even for large data. Arrays require checking each element, which is slower as data grows.

Practice

1. Why do we use a Hash Map instead of a simple list to store key-value pairs?

easy

A. Because it allows fast lookup of values by keys

B. Because it stores data in sorted order automatically

C. Because it uses less memory than a list

D. Because it can only store numbers

Solution

1. Step 1: Understand the problem with lists

   Lists require checking each item one by one to find a value by key, which is slow for large data.

2. Step 2: How hash maps solve this

   Hash maps use a special function to find the exact place of a key quickly, making lookup fast.

3. Final Answer:

   Because it allows fast lookup of values by keys -> Option A

4. Quick Check:

   Fast key lookup = Because it allows fast lookup of values by keys [OK]

Hint: Hash maps speed up key-based searches [OK]

Common Mistakes:

• Thinking hash maps sort data automatically
• Believing hash maps use less memory always
• Assuming hash maps only store numbers

2. Which of the following is the correct way to create a hash map (Map) in TypeScript?

easy

A. const map = new Map();

B. const map = Map();

C. const map = new map();

D. const map = new Map(); string, number;

Solution

1. Step 1: Recall TypeScript Map syntax

   In TypeScript, a Map is created using new Map<KeyType, ValueType>().

2. Step 2: Check each option

   const map = new Map(); uses correct syntax with new Map<string, number>(). Others have syntax errors or wrong casing.

3. Final Answer:

   const map = new Map<string, number>(); -> Option A

4. Quick Check:

   Correct Map creation syntax = const map = new Map<string, number>(); [OK]

Hint: Use 'new Map<KeyType, ValueType>()' to create hash maps [OK]

Common Mistakes:

• Omitting 'new' keyword
• Using lowercase 'map' instead of 'Map'
• Incorrect generic syntax

3. What will be the output of the following TypeScript code?

const map = new Map();
map.set('apple', 5);
map.set('banana', 3);
map.set('apple', 10);
console.log(map.get('apple'));

medium

A. Error

B. 5

C. undefined

D. 10

Solution

1. Step 1: Understand map.set behavior

   When setting a key that already exists, the value is updated to the new one.

2. Step 2: Trace the code

   First 'apple' is set to 5, then updated to 10. So map.get('apple') returns 10.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   Updated value for 'apple' = 10 [OK]

Hint: Last set value for a key overwrites previous [OK]

Common Mistakes:

• Assuming first value remains
• Thinking get returns undefined if key repeated
• Expecting error on duplicate keys

4. Identify the error in this TypeScript code that tries to use a hash map:

const map = new Map();
map['key'] = 'value';
console.log(map.get('key'));

medium

A. map.get() cannot be used to retrieve values

B. Map constructor requires key and value types

C. Using bracket notation to add key-value pairs does not work with Map

D. Map keys must be numbers only

Solution

1. Step 1: Understand how to add entries to Map

   Map entries must be added using map.set(key, value), not bracket notation.

2. Step 2: Analyze the code behavior

   Using map['key'] = 'value' adds a property to the object, not a Map entry, so map.get('key') returns undefined.

3. Final Answer:

   Using bracket notation to add key-value pairs does not work with Map -> Option C

4. Quick Check:

   Use map.set() to add entries [OK]

Hint: Use map.set() to add entries, not bracket notation [OK]

Common Mistakes:

• Adding entries with bracket notation
• Expecting map.get() to find bracket-added keys
• Thinking Map keys must be numbers

5. You want to count how many times each word appears in a list of words using a hash map in TypeScript. Which approach correctly solves this problem?

hard

A. Use a Set to store words and count size for each word

B. Use a Map, for each word check if it exists, then increment or set to 1

C. Use a Map with word as value and count as key

D. Use an array and push words, then count duplicates manually later

Solution

1. Step 1: Understand the counting problem

   We need to store each word as a key and count as a value, so Map<string, number> fits well.

2. Step 2: How to update counts

   For each word, check if it exists in the map; if yes, increment count, else set count to 1.

3. Step 3: Why other options fail

   Use an array and push words, then count duplicates manually later is inefficient and manual. Use a Map with word as value and count as key swaps key and value wrongly. Use a Set to store words and count size for each word's Set only stores unique words without counts.

4. Final Answer:

   Use a Map<string, number>, for each word check if it exists, then increment or set to 1 -> Option B

5. Quick Check:

   Counting words = Map with word keys and number counts [OK]

Hint: Map keys = words, values = counts; increment or set 1 [OK]

Common Mistakes:

• Using Set which can't count duplicates
• Swapping key and value types in Map
• Counting manually with arrays inefficiently