Two Pointer Technique on Arrays in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two Pointer Sum Check

What is the output of the following C++ code that uses two pointers to check if any two numbers sum to 10?

DSA C++

int arr[] = {1, 2, 3, 7, 8, 9};
int n = 6;
int left = 0, right = n - 1;
bool found = false;
while (left < right) {
    int sum = arr[left] + arr[right];
    if (sum == 10) {
        found = true;
        break;
    } else if (sum < 10) {
        left++;
    } else {
        right--;
    }
}
if (found) {
    std::cout << "Yes" << std::endl;
} else {
    std::cout << "No" << std::endl;
}

A Yes

B No

C Compilation Error

D Runtime Error

💡 Hint

Think about pairs that add up to 10 in the sorted array.

The two pointers start at the beginning and end of the array. The pair (1,9) sums to 10, so the output is "Yes".

❓ Predict Output

intermediate

Resulting Array After Removing Duplicates Using Two Pointers

What is the output array after running this C++ code that removes duplicates from a sorted array using two pointers?

DSA C++

int arr[] = {1, 1, 2, 2, 3, 4, 4, 5};
int n = 8;
int j = 0;
for (int i = 1; i < n; i++) {
    if (arr[i] != arr[j]) {
        j++;
        arr[j] = arr[i];
    }
}
for (int k = 0; k <= j; k++) {
    std::cout << arr[k] << " ";
}

A 1 2 3 4 5

B 1 1 2 2 3 4 4 5

C 1 2 3 4 4 5

D 1 2 3 5

💡 Hint

Duplicates are overwritten by unique elements as j moves forward.

The code moves unique elements forward and prints only unique values: 1 2 3 4 5.

🔧 Debug

advanced

Identify the Error in Two Pointer Partition Code

What error does the following C++ code produce when trying to partition an array around a pivot using two pointers?

DSA C++

int arr[] = {5, 2, 9, 1, 5, 6};
int n = 6;
int pivot = 5;
int left = 0, right = n - 1;
while (left <= right) {
    while (arr[left] < pivot) left++;
    while (arr[right] > pivot) right--;
    if (left < right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
        left++;
        right--;
    } else {
        break;
    }
}
for (int i = 0; i < n; i++) {
    std::cout << arr[i] << " ";
}

A Correct partitioned array output

B Compilation error due to missing semicolon

C Runtime error due to out-of-bounds access

D Infinite loop

💡 Hint

Check the loop condition and pointer updates carefully.

The condition 'left <= right' with 'if (left < right)' inside causes the pointers to get stuck when left == right, leading to an infinite loop.

❓ Predict Output

advanced

Output of Merging Two Sorted Arrays Using Two Pointers

What is the output of the following C++ code that merges two sorted arrays using two pointers?

DSA C++

int arr1[] = {1, 3, 5};
int arr2[] = {2, 4, 6};
int n1 = 3, n2 = 3;
int i = 0, j = 0;
std::vector<int> merged;
while (i < n1 && j < n2) {
    if (arr1[i] < arr2[j]) {
        merged.push_back(arr1[i++]);
    } else {
        merged.push_back(arr2[j++]);
    }
}
while (i < n1) merged.push_back(arr1[i++]);
while (j < n2) merged.push_back(arr2[j++]);
for (int x : merged) std::cout << x << " ";

A 2 4 6 1 3 5

B 1 3 5 2 4 6

C 1 2 3 4 5 6

D 1 2 3 5 4 6

💡 Hint

Two pointers pick the smaller element from each array step by step.

The code merges two sorted arrays into one sorted array: 1 2 3 4 5 6.

🧠 Conceptual

expert

Minimum Number of Operations to Make Array Non-Decreasing Using Two Pointers

Given an array, you want to make it non-decreasing by incrementing elements. Using a two pointer approach, what is the minimum number of increments needed for the array [3, 2, 5, 1, 7]?

A 5

B 6

C 7

D 8

💡 Hint

Increment elements that are smaller than the previous to match or exceed it.

Increment 2 to 3 (+1), 1 to 5 (+4), total increments = 1 + 4 + 1 (for 5 to 5) = 6.

Practice

1. What is the main idea behind the Two Pointer Technique when used on arrays?

easy

A. Use two indices to scan the array from different ends or positions simultaneously

B. Use two nested loops to compare every pair of elements

C. Sort the array first and then use binary search

D. Use a single pointer to iterate through the array

Solution

1. Step 1: Understand the technique

   The Two Pointer Technique uses two indices to traverse the array, often from opposite ends or different positions, to solve problems efficiently.

2. Step 2: Compare with other options

   Options B and C describe different methods, and D uses only one pointer, so they do not match the Two Pointer Technique.

3. Final Answer:

   Use two indices to scan the array from different ends or positions simultaneously -> Option A

4. Quick Check:

   Two pointers = two indices scanning array [OK]

Hint: Two pointers move independently to cover array efficiently [OK]

Common Mistakes:

• Thinking it always requires sorting first
• Confusing with nested loops approach
• Using only one pointer instead of two

2. Which of the following is the correct syntax to initialize two pointers left and right for an array arr of size n in C++?

easy

A. int left = n - 1, right = 0;

B. int left = 1, right = n;

C. int left = n, right = 0;

D. int left = 0, right = n - 1;

Solution

1. Step 1: Understand pointer initialization

   For two pointers scanning from start and end, left starts at 0 and right at n-1 (last index).

2. Step 2: Check each option

   int left = 0, right = n - 1; correctly sets left=0 and right=n-1. Options A, B, and C have incorrect indices that may cause out-of-bound errors.

3. Final Answer:

   int left = 0, right = n - 1; -> Option D

4. Quick Check:

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

Hint: Start left at 0 and right at n-1 for full array scan [OK]

Common Mistakes:

• Setting right pointer to n (out of bounds)
• Swapping left and right initial values
• Starting left pointer at 1 instead of 0

3. What will be the output of the following C++ code snippet?

int arr[] = {1, 2, 3, 4, 5, 6};
int left = 0, right = 5;
int sum = 0;
while (left < right) {
    sum += arr[left] + arr[right];
    left++;
    right--;
}
std::cout << sum << std::endl;

medium

A. 27

B. 18

C. 21

D. 15

Solution

1. Step 1: Trace the loop iterations

   Initial pointers: left=0, right=5
   Iteration 1: sum=0+arr[0]+arr[5]=0+1+6=7, left=1, right=4
   Iteration 2: sum=7+arr[1]+arr[4]=7+2+5=14, left=2, right=3
   Iteration 3: sum=14+arr[2]+arr[3]=14+3+4=21, left=3, right=2 (loop ends)

2. Step 2: Final sum value

   Sum after loop is 21.

3. Final Answer:

   21 -> Option C

4. Quick Check:

   Sum pairs (1+6)+(2+5)+(3+4) = 21 [OK]

Hint: Add pairs from ends moving inward until pointers cross [OK]

Common Mistakes:

• Including middle element when pointers cross
• Adding elements twice
• Incorrect loop condition (<= instead of <)

4. Identify the error in the following code that uses the two pointer technique to find if a sorted array contains two numbers that sum to a target value.

bool hasPairSum(int arr[], int n, int target) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int sum = arr[left] + arr[right];
        if (sum == target) return true;
        else if (sum < target) left++;
        else right--;
    }
    return false;
}

medium

A. The loop condition should be left < right instead of left <= right

B. The pointers should be initialized as left = 1 and right = n

C. The sum calculation should be arr[left] - arr[right]

D. The function should return false inside the loop

Solution

1. Step 1: Analyze loop condition

   The loop runs while left <= right, which allows pointers to be equal, causing sum of same element twice.

2. Step 2: Correct loop condition

   Changing condition to left < right ensures pointers do not overlap, avoiding incorrect sum calculation.

3. Final Answer:

   The loop condition should be left < right instead of left <= right -> Option A

4. Quick Check:

   Pointers must not cross or overlap [OK]

Hint: Use left < right to avoid using same element twice [OK]

Common Mistakes:

• Allowing pointers to be equal causing wrong sums
• Incorrect pointer initialization
• Returning false too early inside loop

5. Given a sorted array arr of size n, how can you use the two pointer technique to find all unique pairs that sum up to a target value t? Which approach is correct?

hard

A. Use nested loops to check every pair and store unique pairs in a set

B. Initialize left = 0 and right = n - 1, move pointers inward, skip duplicates after finding a pair

C. Sort the array, then use binary search for each element to find complement

D. Initialize left = 1 and right = n, move pointers outward

Solution

1. Step 1: Set pointers and move inward

   Start with left at 0 and right at n-1. Move pointers inward based on sum compared to target.

2. Step 2: Skip duplicates to find unique pairs

   After finding a pair, increment left and decrement right while skipping duplicate values to avoid repeated pairs.

3. Final Answer:

   Initialize left = 0 and right = n - 1, move pointers inward, skip duplicates after finding a pair -> Option B

4. Quick Check:

   Two pointers inward + skip duplicates = unique pairs [OK]

Hint: Skip duplicates after finding pairs to avoid repeats [OK]

Common Mistakes:

• Not skipping duplicates causing repeated pairs
• Using nested loops causing higher time complexity
• Incorrect pointer initialization or movement