Why Two Pointer Technique Beats Brute Force in DSA Typescript - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Brute Force vs Two Pointer Sum Check

Given the array [1, 3, 4, 5, 7] and target sum 8, what is the output of the two functions below?

Function bruteForceSum checks all pairs for sum. Function twoPointerSum uses two pointers on sorted array.

DSA Typescript

function bruteForceSum(arr: number[], target: number): boolean {
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[i] + arr[j] === target) {
        return true;
      }
    }
  }
  return false;
}

function twoPointerSum(arr: number[], target: number): boolean {
  let left = 0;
  let right = arr.length - 1;
  while (left < right) {
    const sum = arr[left] + arr[right];
    if (sum === target) {
      return true;
    } else if (sum < target) {
      left++;
    } else {
      right--;
    }
  }
  return false;
}

console.log(bruteForceSum([1, 3, 4, 5, 7], 8));
console.log(twoPointerSum([1, 3, 4, 5, 7], 8));

A true\ntrue

B false\ntrue

C true\nfalse

D false\nfalse

💡 Hint

Check if any two numbers add up to 8 in the array.

Both functions find the pair (1,7) that sums to 8, so both return true.

❓ Predict Output

intermediate

Output of Two Pointer Technique on Unsorted Array

What is the output of the twoPointerSum function when called with an unsorted array [9, 1, 7, 2] and target 8?

DSA Typescript

function twoPointerSum(arr: number[], target: number): boolean {
  let left = 0;
  let right = arr.length - 1;
  while (left < right) {
    const sum = arr[left] + arr[right];
    if (sum === target) {
      return true;
    } else if (sum < target) {
      left++;
    } else {
      right--;
    }
  }
  return false;
}

console.log(twoPointerSum([9, 1, 7, 2], 8));

A true

B false

C SyntaxError

D TypeError

💡 Hint

Two pointer technique requires sorted array to work correctly.

The array is unsorted, so the two pointer method misses pairs like (1,7). It returns false.

🧠 Conceptual

advanced

Why Two Pointer Technique is More Efficient Than Brute Force

Which of the following best explains why the two pointer technique is more efficient than brute force for finding pairs that sum to a target in a sorted array?

A It uses two indices moving inward, reducing the number of checks from quadratic to linear time.

B It uses recursion to divide the array and check pairs faster.

C It sorts the array first, which makes the brute force check faster.

D It uses nested loops to check all pairs, which is faster on sorted arrays.

💡 Hint

Think about how many pairs are checked in each method.

Two pointer technique moves pointers inward and checks pairs in linear time O(n), while brute force checks all pairs in O(n²).

🔧 Debug

advanced

Identify the Bug in Two Pointer Implementation

What error will the following code produce when run?

function twoPointerSum(arr: number[], target: number): boolean {
  let left = 0;
  let right = arr.length;
  while (left < right) {
    const sum = arr[left] + arr[right];
    if (sum === target) {
      return true;
    } else if (sum < target) {
      left++;
    } else {
      right--;
    }
  }
  return false;
}

twoPointerSum([1, 2, 3, 4], 5);

A IndexError

B SyntaxError

C undefined + number results in NaN, returns false

D No error, returns true

💡 Hint

Check the initial value of right and array indexing.

Although right is initialized to arr.length causing an out-of-bounds access and undefined, resulting in NaN for sum, JavaScript comparisons involving NaN always evaluate to false. Thus, the else branch is taken, decrementing right, and the function proceeds correctly to return true. No error is thrown.

🚀 Application

expert

Find All Unique Pairs with Two Pointer Technique

Given a sorted array [-2, 0, 1, 1, 2, 3], which option correctly outputs all unique pairs that sum to 2 using the two pointer technique?

DSA Typescript

function findPairs(arr: number[], target: number): Array<[number, number]> {
  const result: Array<[number, number]> = [];
  let left = 0;
  let right = arr.length - 1;
  while (left < right) {
    const sum = arr[left] + arr[right];
    if (sum === target) {
      result.push([arr[left], arr[right]]);
      left++;
      right--;
      while (left < right && arr[left] === arr[left - 1]) left++;
      while (left < right && arr[right] === arr[right + 1]) right--;
    } else if (sum < target) {
      left++;
    } else {
      right--;
    }
  }
  return result;
}

console.log(findPairs([-2, 0, 1, 1, 2, 3], 2));

A [[-2,4],[0,2],[1,1]]

B [[-2,4],[0,2],[1,1],[1,1]]

C [[-2,4],[0,2]]

D [[0,2],[1,1]]

💡 Hint

Check which pairs actually sum to 2 and avoid duplicates.

Pairs that sum to 2 are (0,2) and (1,1). There is no 4 in the array, so options with 4 are invalid.

Practice

1. Why does the two pointer technique often perform better than the brute force approach in problems involving sorted arrays?

easy

A. It reduces the number of comparisons by moving pointers inward based on conditions.

B. It uses recursion to explore all possibilities efficiently.

C. It sorts the array first to make searching faster.

D. It uses extra memory to store intermediate results.

Solution

1. Step 1: Understand brute force approach

   Brute force checks all pairs, leading to many unnecessary comparisons.

2. Step 2: Analyze two pointer technique advantage

   Two pointers move inward based on conditions, skipping unnecessary checks and reducing time.

3. Final Answer:

   It reduces the number of comparisons by moving pointers inward based on conditions. -> Option A

4. Quick Check:

   Two pointer skips pairs, faster than brute force [OK]

Hint: Two pointers move inward to skip unnecessary checks [OK]

Common Mistakes:

• Thinking recursion is always faster
• Confusing sorting with two pointer technique
• Assuming extra memory is used in two pointer

2. Which of the following is the correct syntax to initialize two pointers in TypeScript for an array named arr?

easy

A. let left = arr[0], right = arr[arr.length];

B. let left = 0, right = arr.length - 1;

C. let left = 1, right = arr.length;

D. let left = arr.length, right = 0;

Solution

1. Step 1: Identify valid pointer indices

   Array indices start at 0 and end at length - 1.

2. Step 2: Check each option

   let left = 0, right = arr.length - 1; correctly sets left to 0 and right to last index (length - 1). Others use invalid indices.

3. Final Answer:

   let left = 0, right = arr.length - 1; -> Option B

4. Quick Check:

   Array indices start at 0 [OK]

Hint: Array indices go from 0 to length-1 [OK]

Common Mistakes:

• Starting pointer at 1 instead of 0
• Using arr.length as index (out of bounds)
• Swapping left and right pointers

3. Consider the following TypeScript code using two pointers to find if a sorted array contains two numbers that sum to 10:

const arr = [1, 2, 3, 7, 8, 9];
let left = 0;
let right = arr.length - 1;
let found = false;
while (left < right) {
  const sum = arr[left] + arr[right];
  if (sum === 10) {
    found = true;
    break;
  } else if (sum < 10) {
    left++;
  } else {
    right--;
  }
}
console.log(found);

What will be printed?

medium

A. Error

B. false

C. undefined

D. true

Solution

1. Step 1: Trace pointer values and sums

   Start: left=0(arr[0]=1), right=5(arr[5]=9), sum=10 -> found=true, loop breaks.

2. Step 2: Confirm output

   Since found is set to true, console.log prints true.

3. Final Answer:

   true -> Option D

4. Quick Check:

   1 + 9 = 10 found [OK]

Hint: Check sum at pointers, move accordingly [OK]

Common Mistakes:

• Not breaking loop after finding sum
• Confusing pointer increments
• Assuming array is unsorted

4. The following TypeScript code tries to find two numbers in a sorted array that sum to 15 using two pointers, but it has a bug:

const arr = [2, 4, 6, 8, 10];
let left = 0;
let right = arr.length;
let found = false;
while (left < right) {
  const sum = arr[left] + arr[right];
  if (sum === 15) {
    found = true;
    break;
  } else if (sum < 15) {
    left++;
  } else {
    right--;
  }
}
console.log(found);

What is the bug?

medium

A. right pointer is initialized out of array bounds

B. left pointer should start at 1

C. sum comparison should be with 10 instead of 15

D. The loop condition should be left <= right

Solution

1. Step 1: Check pointer initialization

   right is set to arr.length which is out of bounds (max index is length - 1).

2. Step 2: Understand impact of bug

   Accessing arr[right] causes runtime error or undefined behavior.

3. Final Answer:

   right pointer is initialized out of array bounds -> Option A

4. Quick Check:

   Array indices max is length-1 [OK]

Hint: Right pointer must be length - 1, not length [OK]

Common Mistakes:

• Starting left pointer at 1
• Changing sum target incorrectly
• Using <= instead of < in loop

5. You have a sorted array arr = [1, 3, 4, 5, 7, 10, 12]. Using the two pointer technique, how many unique pairs sum to 13?

hard

A. 4

B. 3

C. 2

D. 1

Solution

1. Step 1: Initialize pointers and check sums

   left=0(arr[0]=1), right=6(arr[6]=12), sum=13 -> count=1, move left++ and right--

2. Step 2: Continue checking pairs

   left=1(arr[1]=3), right=5(arr[5]=10), sum=13 -> count=2, move left++ and right--

3. Step 3: Check next pair

   left=2(arr[2]=4), right=4(arr[4]=7), sum=11 < 13 -> move left++

4. Step 4: Check final pair

   left=3(arr[3]=5), right=4(arr[4]=7), sum=12 < 13 -> move left++

5. Step 5: Pointers crossed, stop

   Total pairs found = 2

6. Final Answer:

   2 -> Option C

7. Quick Check:

   Pairs (1,12) and (3,10) sum to 13 [OK]

Hint: Move pointers inward, count pairs summing to target [OK]

Common Mistakes:

• Counting pairs with same elements twice
• Not moving pointers correctly after sum check
• Assuming pairs must be adjacent