Why Two Pointer Technique Beats Brute Force in DSA Python - See It Work

Why Two Pointer Technique Beats Brute Force

📖 Scenario: Imagine you have a list of numbers representing the heights of walls. You want to find two walls that together can hold the most water between them. This is like finding the biggest container formed by two walls.

🎯 Goal: You will first try the simple but slow way (brute force) to find the maximum water container. Then, you will use the faster two pointer technique to do the same task efficiently.

📋 What You'll Learn

Create a list called heights with exact values: [1, 8, 6, 2, 5, 4, 8, 3, 7]

Create a variable called max_area_brute and set it to 0

Use nested for loops with variables i and j to check all pairs of walls in heights

Calculate area as (j - i) * min(heights[i], heights[j]) inside the loops and update max_area_brute if this area is bigger

Create two pointers left and right starting at the ends of heights

Create a variable called max_area_two_pointer and set it to 0

Use a while loop to move left and right pointers towards each other, calculating area and updating max_area_two_pointer

Print both max_area_brute and max_area_two_pointer to compare results

💡 Why This Matters

🌍 Real World

This technique helps in problems where you need to find pairs or ranges efficiently, like in water container problems, string matching, or array processing.

💼 Career

Understanding two pointer technique is important for coding interviews and real-world tasks that require optimized solutions over brute force.

1

Create the list of wall heights

Create a list called heights with these exact values: [1, 8, 6, 2, 5, 4, 8, 3, 7]

DSA Python

# Create the list heights with the given values
# Your code here

Hint

Use square brackets to create the list and separate numbers with commas.

2

Set up variables for brute force and two pointer methods

Create a variable called max_area_brute and set it to 0. Also create variables left and right with values 0 and len(heights) - 1 respectively. Finally, create a variable called max_area_two_pointer and set it to 0.

DSA Python

heights = [1, 8, 6, 2, 5, 4, 8, 3, 7]
# Create max_area_brute = 0
# Create left = 0 and right = len(heights) - 1
# Create max_area_two_pointer = 0
# Your code here

Hint

Use simple assignment statements to create these variables.

3

Calculate max area using brute force and two pointer technique

Use nested for loops with variables i and j to check all pairs of walls in heights. Calculate area as (j - i) * min(heights[i], heights[j]) and update max_area_brute if this area is bigger. Then use a while loop with left and right pointers moving towards each other. Calculate area inside the loop and update max_area_two_pointer. Move left pointer forward if heights[left] is less than heights[right], else move right pointer backward.

DSA Python

heights = [1, 8, 6, 2, 5, 4, 8, 3, 7]
max_area_brute = 0
left = 0
right = len(heights) - 1
max_area_two_pointer = 0
# Add nested for loops for brute force
# Add while loop for two pointer technique
# Your code here

Hint

Use two nested loops for brute force and a while loop with two pointers for the efficient method.

4

Print the results to compare both methods

Print max_area_brute and max_area_two_pointer on separate lines to compare the maximum water container areas found by both methods.

DSA Python

heights = [1, 8, 6, 2, 5, 4, 8, 3, 7]
max_area_brute = 0
left = 0
right = len(heights) - 1
max_area_two_pointer = 0

for i in range(len(heights)):
    for j in range(i + 1, len(heights)):
        area = (j - i) * min(heights[i], heights[j])
        if area > max_area_brute:
            max_area_brute = area

while left  max_area_two_pointer:
        max_area_two_pointer = area
    if heights[left] < heights[right]:
        left += 1
    else:
        right -= 1
# Print max_area_brute and max_area_two_pointer
# Your code here

Hint

Use two print statements, one for each max area variable.

Practice

1. What is the main advantage of the two pointer technique over brute force in array problems?

easy

A. It requires recursion to work properly

B. It uses more memory to store intermediate results

C. It always sorts the array before processing

D. It reduces time complexity by avoiding nested loops

Solution

1. Step 1: Understand brute force approach

   Brute force often uses nested loops, leading to higher time complexity like O(n²).

2. Step 2: Analyze two pointer technique

   Two pointers move through the array in a single pass, reducing time complexity to O(n).

3. Final Answer:

   It reduces time complexity by avoiding nested loops -> Option D

4. Quick Check:

   Two pointer = faster than brute force [OK]

Hint: Two pointers scan once, brute force scans many times [OK]

Common Mistakes:

• Thinking two pointer always sorts the array
• Confusing memory use with speed
• Assuming recursion is needed

2. Which of the following is the correct syntax to initialize two pointers at the start and end of a list named arr in Python?

easy

A. left = 0; right = len(arr) - 1

B. left = 1; right = len(arr)

C. left = len(arr); right = 0

D. left = -1; right = len(arr) + 1

Solution

1. Step 1: Identify valid indices in Python list

   Python lists start at index 0 and end at len(arr) - 1.

2. Step 2: Check pointer initialization

   Left pointer should be 0 (start), right pointer should be len(arr) - 1 (end).

3. Final Answer:

   left = 0; right = len(arr) - 1 -> Option A

4. Quick Check:

   Start = 0, End = length-1 [OK]

Hint: Start pointer at 0, end pointer at length minus one [OK]

Common Mistakes:

• Starting pointers outside valid index range
• Using 1-based indexing in Python
• Setting right pointer to len(arr) instead of len(arr)-1

3. What will be the output of the following Python code using two pointers?

def two_sum_sorted(arr, target):
    left, right = 0, len(arr) - 1
    while left < right:
        current_sum = arr[left] + arr[right]
        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    return [-1, -1]

print(two_sum_sorted([1, 3, 4, 5, 7, 10], 9))

medium

A. [0, 5]

B. [1, 3]

C. [2, 3]

D. [-1, -1]

Solution

1. Step 1: Trace the execution step-by-step

   arr = [1,3,4,5,7,10]
   left=0 (1), right=5 (10), sum=11 >9 -> right=4
   left=0 (1), right=4 (7), sum=8 <9 -> left=1
   left=1 (3), right=4 (7), sum=10 >9 -> right=3
   left=1 (3), right=3 (5), sum=8 <9 -> left=2
   left=2 (4), right=3 (5), sum=9 ==9 -> return [2, 3]

2. Final Answer:

   [2, 3] -> Option C

3. Quick Check:

   arr[2] + arr[3] = 4 + 5 = 9 [OK]

Hint: Move pointers based on sum compared to target [OK]

Common Mistakes:

• Not updating pointers correctly
• Returning wrong indices
• Confusing array values with indices

4. Find the error in this two pointer code snippet that tries to find if a pair sums to target in a sorted list:

def has_pair(arr, target):
    left, right = 0, len(arr)
    while left < right:
        if arr[left] + arr[right] == target:
            return True
        elif arr[left] + arr[right] < target:
            left += 1
        else:
            right -= 1
    return False

medium

A. left should start at 1 instead of 0

B. right should be initialized to len(arr) - 1

C. The while condition should be left <= right

D. The function should return indices instead of True/False

Solution

1. Step 1: Check pointer initialization

   right is set to len(arr), which is out of valid index range (max index is len(arr)-1).

2. Step 2: Correct pointer initialization

   right should be len(arr) - 1 to point to last element.

3. Final Answer:

   right should be initialized to len(arr) - 1 -> Option B

4. Quick Check:

   Valid indices = 0 to length-1 [OK]

Hint: Right pointer must be last valid index, not length [OK]

Common Mistakes:

• Using len(arr) as index causes IndexError
• Changing left pointer start incorrectly
• Misusing while loop condition

5. Given a sorted array arr and a target sum, how does the two pointer technique efficiently find all unique pairs that add up to the target compared to brute force?

hard

A. By moving pointers inward and skipping duplicates, it avoids checking all pairs

B. By sorting the array multiple times to find pairs quickly

C. By using nested loops to check every possible pair

D. By using recursion to split the array and find pairs

Solution

1. Step 1: Understand brute force approach

   Brute force checks every pair with nested loops, O(n²) time.

2. Step 2: Explain two pointer efficiency

   Two pointers start at ends, move inward based on sum comparison, skipping duplicates to avoid repeats, achieving O(n) time.

3. Final Answer:

   By moving pointers inward and skipping duplicates, it avoids checking all pairs -> Option A

4. Quick Check:

   Two pointer skips pairs, brute force checks all [OK]

Hint: Skip duplicates and move pointers inward for efficiency [OK]

Common Mistakes:

• Thinking sorting happens multiple times
• Confusing recursion with two pointer
• Assuming nested loops are used in two pointer