Remove Duplicates from Sorted Array Two Pointer in DSA C++ - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the slow pointer at the start of the array.

DSA C++

int slow = [1];

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

A1

B-1

Cnums.size()

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Starting slow pointer at 1 instead of 0.

Using negative indices which are invalid here.

The slow pointer starts at index 0 to track the position of unique elements.

2fill in blank

medium

Complete the code to iterate through the array starting from the second element.

DSA C++

for (int fast = [1]; fast < nums.size(); fast++) {

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

A0

B2

C1

Dnums.size() - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting fast pointer at 0 causing redundant comparison.

Starting at index beyond array size.

The fast pointer starts at index 1 to compare with the slow pointer at index 0.

3fill in blank

hard

Fix the error in the condition to check if current element is different from last unique element.

DSA C++

if (nums[fast] [1] nums[slow]) {

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

A!=

B==

C<

D>

Attempts:

3 left

💡 Hint

Common Mistakes

Using '==' which detects duplicates instead of unique elements.

Using '<' or '>' which is not reliable for equality check.

We check if the current element is not equal to the last unique element to identify duplicates.

4fill in blank

hard

Fill both blanks to update the slow pointer and assign the new unique element.

DSA C++

[1];
nums[slow] = nums[[2]];

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

A++slow

Bfast

Cslow

D--slow

Attempts:

3 left

💡 Hint

Common Mistakes

Assigning nums[slow] to nums[fast] instead of the other way.

Not incrementing slow pointer before assignment.

We first move slow pointer forward, then assign the current fast element to that position.

5fill in blank

hard

Fill all three blanks to complete the function returning the count of unique elements.

DSA C++

int removeDuplicates(vector<int>& nums) {
    if (nums.empty()) return 0;
    int slow = [1];
    for (int fast = [2]; fast < nums.size(); fast++) {
        if (nums[fast] != nums[slow]) {
            slow[3];
            nums[slow] = nums[fast];
        }
    }
    return slow + 1;
}

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

A0

B1

C++

D--

Attempts:

3 left

💡 Hint

Common Mistakes

Starting slow or fast pointers at wrong indices.

Using decrement operator on slow pointer.

Initialize slow at 0, fast at 1, and increment slow before assignment to track unique elements.

Practice

1. What is the main purpose of the two-pointer technique in removing duplicates from a sorted array?

easy

A. To track unique elements and overwrite duplicates in-place

B. To sort the array again after removing duplicates

C. To create a new array with duplicates removed

D. To count the total number of duplicates only

Solution

1. Step 1: Understand the two-pointer roles

   One pointer tracks the position to place unique elements, the other scans the array.

2. Step 2: Overwrite duplicates in-place

   When a new unique element is found, it is placed at the tracked position, replacing duplicates.

3. Final Answer:

   To track unique elements and overwrite duplicates in-place -> Option A

4. Quick Check:

   Two-pointer technique = overwrite duplicates [OK]

Hint: Two pointers: one scans, one writes unique values [OK]

Common Mistakes:

• Thinking it creates a new array instead of modifying in-place
• Assuming it sorts the array again
• Confusing counting duplicates with removing them

2. Which of the following is the correct syntax to initialize the two pointers for removing duplicates from a sorted array nums in C++?

easy

A. int i = 0, j = 1;

B. int i = 1, j = 0;

C. int i = 0, j = 0;

D. int i = 1, j = 1;

Solution

1. Step 1: Identify pointer roles

   Pointer i tracks the last unique element index, starting at 0; j scans from 1.

2. Step 2: Initialize pointers accordingly

   Set i = 0 and j = 1 to start comparing from the second element.

3. Final Answer:

   int i = 0, j = 1; -> Option A

4. Quick Check:

   i=0, j=1 start positions [OK]

Hint: Start i at 0, j at 1 to compare neighbors [OK]

Common Mistakes:

• Starting both pointers at 0
• Swapping i and j initialization
• Starting j before i

3. What will be the output length after removing duplicates using the two-pointer method on the sorted array nums = {1, 1, 2, 3, 3, 4}?

medium

A. 3

B. 4

C. 5

D. 6

Solution

1. Step 1: Identify unique elements in order

   Unique elements are 1, 2, 3, 4.

2. Step 2: Count unique elements

   There are 4 unique elements, so the length after removal is 4.

3. Final Answer:

   4 -> Option B

4. Quick Check:

   Unique count = 4 [OK]

Hint: Count unique numbers in sorted array [OK]

Common Mistakes:

• Counting duplicates as unique
• Confusing length with original array size
• Off-by-one errors in counting

4. Identify the error in the following C++ code snippet for removing duplicates from a sorted array nums:

int removeDuplicates(vector<int>& nums) {
    int i = 0, j = 1;
    while (j < nums.size()) {
        if (nums[i] != nums[j]) {
            i++;
            nums[i] = nums[j];
        }
        j++;
    }
    return i;
}

medium

A. The loop should use for instead of while

B. Pointers i and j should start at 1 and 0 respectively

C. The condition should be nums[i] == nums[j] instead of !=

D. Return value should be i + 1, not i

Solution

1. Step 1: Understand pointer i meaning

   Pointer i is index of last unique element, so length is i + 1.

2. Step 2: Check return statement

   Returning i alone gives index, not count; must return i + 1 for length.

3. Final Answer:

   Return value should be i + 1, not i -> Option D

4. Quick Check:

   Length = last index + 1 [OK]

Hint: Return i + 1 as length, not i [OK]

Common Mistakes:

• Returning i instead of i + 1
• Swapping pointer initializations
• Using wrong comparison operator

5. Given a sorted array nums = {0, 0, 1, 1, 1, 2, 2, 3, 3, 4}, what will be the state of the array after applying the two-pointer method to remove duplicates, and what is the new length?

hard

A. Array: {0, 1, 1, 2, 3, 4, _, _, _, _}, Length: 4

B. Array: {0, 0, 1, 1, 2, 2, 3, 3, 4, 4}, Length: 6

C. Array: {0, 1, 2, 3, 4, _, _, _, _, _}, Length: 5

D. Array: {0, 1, 2, 3, 4, 5, _, _, _, _}, Length: 6

Solution

1. Step 1: Identify unique elements in order

   Unique elements are 0, 1, 2, 3, 4.

2. Step 2: Overwrite duplicates in-place

   Using two pointers, these unique elements overwrite the start of the array.

3. Step 3: Determine new length

   There are 5 unique elements, so length is 5.

4. Final Answer:

   Array: {0, 1, 2, 3, 4, _, _, _, _, _}, Length: 5 -> Option C

5. Quick Check:

   Unique elements = 5, array start updated [OK]

Hint: Unique elements overwrite start, length = count unique [OK]

Common Mistakes:

• Not overwriting duplicates correctly
• Miscounting unique elements
• Assuming array length stays same