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

Practice - 5 Tasks

1fill in blank

easy

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

DSA Java

int slow = [1];

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

Anums.length

B-1

C0

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting slow pointer at 1 instead of 0.

Initializing slow pointer with array length.

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

2fill in blank

medium

Complete the code to start the fast pointer from the second element.

DSA Java

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

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

A1

B0

C2

Dnums.length - 1

Attempts:

3 left

💡 Hint

Common Mistakes

Starting fast pointer at 0 causing redundant comparison.

Starting fast pointer beyond the second element.

The fast pointer starts at index 1 to compare with the slow pointer's element.

3fill in blank

hard

Fix the error in the condition to check if current fast element is different from slow element.

DSA Java

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 '==' instead of '!=' causing no duplicates to be removed.

Using greater than or less than operators which are incorrect here.

We check if the fast element is not equal to the slow element to find a new unique element.

4fill in blank

hard

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

DSA Java

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

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

A++

B--

Cfast

Dslow

Attempts:

3 left

💡 Hint

Common Mistakes

Decrementing slow pointer instead of incrementing.

Assigning nums[slow] to nums[slow] instead of nums[fast].

We increment slow to move to the next position and assign nums[fast] to nums[slow].

5fill in blank

hard

Fill all three blanks to return the length of unique elements after processing.

DSA Java

return slow [1] [2];

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

A+

B-

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Returning slow without adding 1 causing off-by-one error.

Subtracting 1 from slow causing negative or wrong length.

We return slow + 1 because slow is index-based, so length is index + 1.

Practice

1. What is the main purpose of using two pointers in the Remove Duplicates from Sorted Array problem?

easy

A. To sort the array before removing duplicates

B. To count the total number of duplicates in the array

C. To create a new array with unique elements

D. To efficiently track unique elements and overwrite duplicates in-place

Solution

1. Step 1: Understand the two-pointer approach

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

2. Step 2: Purpose of pointers in-place

   This method avoids extra space by overwriting duplicates, keeping unique elements at the start.

3. Final Answer:

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

4. Quick Check:

   Two pointers help remove duplicates without extra space [OK]

Hint: Two pointers move to keep unique elements compact [OK]

Common Mistakes:

• Thinking two pointers sort the array
• Assuming a new array is created
• Confusing counting duplicates with removing them

2. Which of the following is the correct syntax to initialize the two pointers i and j for the problem in Java?

easy

A. int i = 0, j = 1;

B. int i = 1, j = 0;

C. int i = 0; int j = 0;

D. int i = 1; int j = 1;

Solution

1. Step 1: Identify pointer roles

   Pointer i starts at 0 to track unique elements, j starts at 1 to scan ahead.

2. Step 2: Check initialization correctness

   Initializing i = 0 and j = 1 allows scanning from second element while i marks last unique.

3. Final Answer:

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

4. Quick Check:

   Start i at 0, j at 1 to scan array [OK]

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

Common Mistakes:

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

3. What will be the output length after removing duplicates using two pointers on the sorted array [1, 1, 2, 2, 3]?

medium

A. 2

B. 3

C. 5

D. 4

Solution

1. Step 1: Trace the two-pointer process

   Start with i=0, j=1; compare elements and overwrite duplicates: unique elements are 1, 2, 3.

2. Step 2: Count unique elements

   After processing, unique elements count is 3.

3. Final Answer:

   3 -> Option B

4. Quick Check:

   Unique elements count = 3 [OK]

Hint: Count unique elements after skipping duplicates [OK]

Common Mistakes:

• Counting duplicates instead of unique
• Assuming length stays same
• Miscounting when duplicates are consecutive

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

int i = 0, j = 1;
while (j < nums.length) {
  if (nums[i] != nums[j]) {
    i++;
    nums[i] = nums[j];
  }
  j++;
}
return i;

medium

A. Pointers initialized incorrectly

B. Incorrect comparison operator used

C. Returns i instead of i + 1 as new length

D. Does not increment j inside the loop

Solution

1. Step 1: Analyze return value

   The variable i tracks last unique index, so length is i + 1.

2. Step 2: Identify mistake in return

   Returning i misses counting the first element, causing length off by one.

3. Final Answer:

   Returns i instead of i + 1 as new length -> Option C

4. Quick Check:

   Length = last index + 1 [OK]

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

Common Mistakes:

• Returning i instead of i + 1
• Forgetting to increment j
• Using wrong comparison operator

5. Given a sorted array nums = [0,0,1,1,1,2,2,3,3,4], what will be the array state after applying the two-pointer method to remove duplicates?

hard

A. [0, 1, 2, 3, 4, _, _, _, _, _]

B. [0, 0, 1, 1, 2, 2, 3, 3, 4, 4]

C. [0, 1, 1, 2, 3, 4, _, _, _, _]

D. [0, 1, 2, 3, 4, 5, _, _, _, _]

Solution

1. Step 1: Apply two-pointer overwrite

   Start with i=0, j=1; overwrite duplicates by moving unique elements forward: unique elements are 0,1,2,3,4.

2. Step 2: Final array state

   First five positions hold unique elements [0,1,2,3,4], rest remain unchanged or ignored.

3. Final Answer:

   [0, 1, 2, 3, 4, _, _, _, _, _] -> Option A

4. Quick Check:

   Unique elements compacted at start [OK]

Hint: Unique elements fill front, duplicates ignored after [OK]

Common Mistakes:

• Assuming duplicates remain in place
• Misplacing unique elements
• Counting extra elements beyond unique count