Remove Duplicates from Sorted Array Two Pointer in DSA Java - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two Pointer Duplicate Removal

What is the output array after running the two-pointer duplicate removal code on the input array?

DSA Java

int[] nums = {1,1,2,2,3,4,4,5};
int k = removeDuplicates(nums);
System.out.print("Length: " + k + ", Array: ");
for (int i = 0; i < k; i++) {
    System.out.print(nums[i] + " ");
}

public static int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

A Length: 6, Array: 1 2 3 4 5 5

B Length: 8, Array: 1 1 2 2 3 4 4 5

C Length: 4, Array: 1 2 3 4

D Length: 5, Array: 1 2 3 4 5

💡 Hint

Use two pointers: one to track unique elements, one to scan through the array.

The two-pointer method moves unique elements to the front. The variable i tracks the last unique element's index. When a new unique element is found at j, it is placed at i+1. The final length is i + 1.

🧠 Conceptual

intermediate

Understanding Two Pointer Approach

Why does the two-pointer approach work efficiently for removing duplicates from a sorted array?

A Because it scans the array once, moving unique elements forward without extra space.

B Because it uses extra space to store unique elements separately.

C Because it sorts the array first before removing duplicates.

D Because it uses recursion to remove duplicates.

💡 Hint

Think about how many times the array is scanned and if extra space is used.

The two-pointer approach scans the array once and moves unique elements forward in-place, so it uses O(1) extra space and O(n) time.

🔧 Debug

advanced

Identify the Bug in Duplicate Removal Code

What error will this code produce when run on input [1,1,2]?

DSA Java

public static int removeDuplicates(int[] nums) {
    int i = 0;
    for (int j = 1; j <= nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

A Infinite loop

B ArrayIndexOutOfBoundsException

C NullPointerException

D No error, returns length 2

💡 Hint

Check the loop condition and array indexing carefully.

The loop uses j <= nums.length, which causes nums[j] to access an index equal to the array length, causing an ArrayIndexOutOfBoundsException.

❓ Predict Output

advanced

Output After Removing Duplicates with Multiple Repeats

What is the output length and array after removing duplicates from this input?

DSA Java

int[] nums = {0,0,1,1,1,2,2,3,3,4};
int k = removeDuplicates(nums);
System.out.print("Length: " + k + ", Array: ");
for (int i = 0; i < k; i++) {
    System.out.print(nums[i] + " ");
}

public static int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

A Length: 5, Array: 0 1 2 3 4

B Length: 10, Array: 0 0 1 1 1 2 2 3 3 4

C Length: 6, Array: 0 1 2 3 4 4

D Length: 4, Array: 0 1 2 3

💡 Hint

Count unique numbers and check how the two-pointer method moves them.

The unique numbers are 0,1,2,3,4. The method moves them to the front and returns length 5.

🧠 Conceptual

expert

Why Two Pointer Method is Preferred Over Using Extra Data Structures?

Why is the two-pointer method preferred for removing duplicates from a sorted array compared to using a HashSet or other extra data structures?

A Because it sorts the array first which is required for duplicates removal.

B Because it uses O(n) extra space but is faster in time.

C Because it modifies the array in-place using O(1) extra space and maintains order.

D Because it uses recursion to reduce code complexity.

💡 Hint

Think about space complexity and preserving order.

The two-pointer method modifies the array in-place, uses constant extra space, and keeps the original order of elements, which is efficient and desirable.

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