Why Two Pointer Technique Beats Brute Force in DSA Typescript - Why This Pattern

Mental Model

Two pointers move through the data in a smart way to avoid checking everything twice.

Analogy: Imagine two friends walking from opposite ends of a hallway to find a meeting spot instead of one friend walking back and forth repeatedly.

Array: [1] -> [2] -> [3] -> [4] -> [5] -> null
Pointers: ↑left                             ↑right

Dry Run Walkthrough

Input: array: [1, 2, 3, 4, 5], find two numbers that sum to 6

Goal: Find two numbers that add up to 6 using two pointers instead of checking all pairs

Step 1: Set left pointer at index 0 (value 1), right pointer at index 4 (value 5)

1 [left] -> 2 -> 3 -> 4 -> 5 [right] -> null

Why: Start checking from both ends to cover all pairs efficiently

Step 2: Calculate sum: 1 + 5 = 6, which matches target

1 [left] -> 2 -> 3 -> 4 -> 5 [right] -> null

Why: Found the pair without checking all pairs

Step 3: Stop search as pair is found

1 [left] -> 2 -> 3 -> 4 -> 5 [right] -> null

Why: No need to continue once the answer is found

Result:

1 [left] -> 2 -> 3 -> 4 -> 5 [right] -> null
Pair found: (1, 5)

Annotated Code

DSA Typescript

class TwoPointer {
  static findPairWithSum(arr: number[], target: number): [number, number] | null {
    let left = 0
    let right = arr.length - 1

    while (left < right) {
      const sum = arr[left] + arr[right]
      if (sum === target) {
        return [arr[left], arr[right]]
      } else if (sum < target) {
        left++ // move left pointer right to increase sum
      } else {
        right-- // move right pointer left to decrease sum
      }
    }
    return null // no pair found
  }
}

// Driver code
const arr = [1, 2, 3, 4, 5]
const target = 6
const result = TwoPointer.findPairWithSum(arr, target)
if (result) {
  console.log(`Pair found: (${result[0]}, ${result[1]})`)
} else {
  console.log('No pair found')
}

while (left < right) {

loop until pointers meet to check all possible pairs

const sum = arr[left] + arr[right]

calculate sum of values at pointers

if (sum === target) { return [arr[left], arr[right]] }

found the pair matching target sum

else if (sum < target) { left++ }

increase sum by moving left pointer right

else { right-- }

decrease sum by moving right pointer left

Output

Pair found: (1, 5)

Complexity Analysis

Time: O(n) because each pointer moves at most n steps through the array once

Space: O(1) because only two pointers and a few variables are used

vs Alternative: Brute force checks all pairs with O(n²) time, which is slower for large arrays

Edge Cases

empty array

returns null immediately as no pairs exist

DSA Typescript

while (left < right) {

array with one element

returns null because two elements are needed for a pair

DSA Typescript

while (left < right) {

no pair sums to target

returns null after pointers cross without finding pair

DSA Typescript

return null // no pair found

When to Use This Pattern

When you need to find pairs or subarrays with certain properties in sorted data, use two pointers to reduce time from quadratic to linear.

Common Mistakes

Mistake: Not moving pointers correctly based on sum comparison
Fix: Move left pointer right if sum is less than target, move right pointer left if sum is greater

Summary

Finds pairs in sorted arrays efficiently by moving two pointers inward.

Use when searching pairs or ranges in sorted data to improve speed.

The key is adjusting pointers based on comparison to target to avoid checking all pairs.

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