Two Sum Problem Classic Hash Solution in DSA Typescript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare the hash map for storing numbers and their indices.

DSA Typescript

const numMap = new Map<number, number>[1];

Drag options to blanks, or click blank then click option'

A[]

B<number, number>()

C{}

D()

Attempts:

3 left

💡 Hint

Common Mistakes

Using square brackets [] which create arrays, not maps.

Using curly braces {} which create objects, not Map instances.

The Map constructor is called with parentheses () to create a new empty map.

2fill in blank

medium

Complete the code to check if the complement exists in the map.

DSA Typescript

if (numMap.[1](complement)) {

Drag options to blanks, or click blank then click option'

Aset

Bhas

Cget

Ddelete

Attempts:

3 left

💡 Hint

Common Mistakes

Using get which returns the value, not a boolean.

Using set which adds or updates a key.

The has method checks if a key exists in the Map.

3fill in blank

hard

Fix the error in the code to add the current number and its index to the map.

DSA Typescript

numMap.[1](nums[i], i);

Drag options to blanks, or click blank then click option'

Aset

Bget

Chas

Dpush

Attempts:

3 left

💡 Hint

Common Mistakes

Using get which retrieves a value.

Using push which is for arrays, not maps.

The set method adds or updates a key-value pair in the Map.

4fill in blank

hard

Fill both blanks to complete the return statement with indices of the two numbers.

DSA Typescript

return [numMap.get([1]), [2]];

Drag options to blanks, or click blank then click option'

Acomplement

Bi

Cnums[i]

DnumMap

Attempts:

3 left

💡 Hint

Common Mistakes

Returning the number itself instead of its index.

Using the wrong variable for the current index.

The first index is found by looking up the complement in the map, the second is the current index i.

5fill in blank

hard

Fill all three blanks to complete the Two Sum function using a hash map.

DSA Typescript

function twoSum(nums: number[], target: number): number[] {
  const numMap = new Map<number, number>[1];
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (numMap.[2](complement)) {
      return [numMap.get(complement), [3]];
    }
    numMap.set(nums[i], i);
  }
  return [];
}

Drag options to blanks, or click blank then click option'

A()

Bhas

Ci

Dget

Attempts:

3 left

💡 Hint

Common Mistakes

Forgetting to initialize the map properly.

Using wrong method names for map operations.

Returning wrong indices.

The map is initialized with (), has checks for complement, and i is the current index returned.

Practice

1. What is the main purpose of using a hash map in the Two Sum problem classic solution?

easy

A. To store the sum of all pairs

B. To sort the array before searching

C. To store numbers and their indices for quick lookup

D. To reverse the array elements

Solution

1. Step 1: Understand the role of hash map

   The hash map stores each number as a key and its index as the value for quick lookup.

2. Step 2: Explain why quick lookup is needed

   Quick lookup helps to find if the complement (target - current number) exists without scanning the entire array again.

3. Final Answer:

   To store numbers and their indices for quick lookup -> Option C

4. Quick Check:

   Hash map stores number:index = A [OK]

Hint: Hash map stores values for instant complement check [OK]

Common Mistakes:

• Thinking hash map sorts the array
• Trying to store sums instead of indices
• Using hash map to reverse elements

2. Which of the following TypeScript code snippets correctly initializes an empty hash map for the Two Sum problem?

easy

A. const map = new Map();

B. const map = {};

C. const map = new Array();

D. const map = new Set();

Solution

1. Step 1: Identify correct hash map initialization

   In TypeScript, new Map<number, number>() creates a map with number keys and values.

2. Step 2: Explain why other options are incorrect

   {} is an object but lacks type safety; new Array() is an array, not a map; new Set() stores unique values, not key-value pairs.

3. Final Answer:

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

4. Quick Check:

   Use Map<number, number> for hash map [OK]

Hint: Use Map<number, number> for key-value pairs [OK]

Common Mistakes:

• Using Set instead of Map
• Using Array instead of Map
• Using plain object without type safety

3. What will be the output of the following TypeScript code for the input array [2, 7, 11, 15] and target 9?

function twoSum(nums: number[], target: number): number[] {
  const map = new Map();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map.has(complement)) {
      return [map.get(complement)!, i];
    }
    map.set(nums[i], i);
  }
  return [];
}

console.log(twoSum([2, 7, 11, 15], 9));

medium

A. [1, 2]

B. []

C. [2, 3]

D. [0, 1]

Solution

1. Step 1: Trace the loop and map updates

   i=0: map={}, complement=9-2=7, map.has(7)? No, map.set(2,0).
   i=1: complement=9-7=2, map.has(2)? Yes, index=0, return [0,1].

2. Step 2: Confirm returned indices

   Indices 0 and 1 correspond to numbers 2 and 7 which sum to 9.

3. Final Answer:

   [0, 1] -> Option D

4. Quick Check:

   Indices of 2 and 7 = [0, 1] [OK]

Hint: Check complement in map before adding current number [OK]

Common Mistakes:

• Returning values instead of indices
• Not checking map before insertion
• Returning empty array incorrectly

4. Identify the bug in this TypeScript Two Sum implementation:

function twoSum(nums: number[], target: number): number[] {
  const map = new Map();
  for (let i = 0; i <= nums.length; i++) {
    const complement = target - nums[i];
    if (map.has(complement)) {
      return [map.get(complement)!, i];
    }
    map.set(nums[i], i);
  }
  return [];
}

medium

A. map.set should be called before checking complement

B. Loop condition should be < instead of <=

C. Return statement should return values instead of indices

D. Complement calculation is incorrect

Solution

1. Step 1: Analyze loop condition

   The loop uses i <= nums.length, which causes out-of-bounds access at last iteration.

2. Step 2: Correct loop condition

   Change to i < nums.length to avoid accessing undefined element.

3. Final Answer:

   Loop condition should be < instead of <= -> Option B

4. Quick Check:

   Loop must stay within array bounds [OK]

Hint: Use < not <= for array index loops [OK]

Common Mistakes:

• Off-by-one error in loop condition
• Swapping order of map.set and map.has
• Returning values instead of indices

5. Given the input array [3, 3, 4, 5] and target 6, what will the Two Sum classic hash solution return?

function twoSum(nums: number[], target: number): number[] {
  const map = new Map();
  for (let i = 0; i < nums.length; i++) {
    const complement = target - nums[i];
    if (map.has(complement)) {
      return [map.get(complement)!, i];
    }
    map.set(nums[i], i);
  }
  return [];
}

console.log(twoSum([3, 3, 4, 5], 6));

hard

A. [0, 1]

B. [1, 2]

C. [2, 3]

D. []

Solution

1. Step 1: Trace the loop and map updates with duplicates

   i=0: map={}, complement=6-3=3, map.has(3)? No, map.set(3,0).
   i=1: complement=6-3=3, map.has(3)? Yes, index=0, return [0,1].

2. Step 2: Confirm correct pair with duplicates

   Even with duplicates, first pair indices 0 and 1 sum to 6.

3. Final Answer:

   [0, 1] -> Option A

4. Quick Check:

   Duplicates handled, indices [0,1] sum to target [OK]

Hint: Duplicates allowed; first matching pair returned [OK]

Common Mistakes:

• Ignoring duplicates and returning wrong indices
• Returning empty array incorrectly
• Confusing values with indices