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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of removing duplicates from sorted array

What is the output of the following C code that removes duplicates from a sorted array using two pointers?

DSA C

int removeDuplicates(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    int i = 0;
    for (int j = 1; j < numsSize; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

int main() {
    int nums[] = {1,1,2,2,3,4,4,5};
    int size = sizeof(nums)/sizeof(nums[0]);
    int newSize = removeDuplicates(nums, size);
    for (int i = 0; i < newSize; i++) {
        printf("%d ", nums[i]);
    }
    return 0;
}

A 1 2 2 3 4 5

B 1 1 2 2 3 4 4 5

C 1 2 3 4 5

D 1 2 3 4 5 5

💡 Hint

Focus on how the two pointers i and j move and how duplicates are skipped.

The code uses two pointers: i tracks the position of the last unique element, and j scans through the array. When nums[j] is different from nums[i], i is incremented and nums[i] is updated to nums[j]. This way, duplicates are overwritten and the array's first part contains unique elements.

❓ Predict Output

intermediate

Value of newSize after removing duplicates

What is the value of newSize after running the removeDuplicates function on the array {0,0,1,1,1,2,2,3,3,4}?

DSA C

int removeDuplicates(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    int i = 0;
    for (int j = 1; j < numsSize; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

int main() {
    int nums[] = {0,0,1,1,1,2,2,3,3,4};
    int size = sizeof(nums)/sizeof(nums[0]);
    int newSize = removeDuplicates(nums, size);
    printf("%d", newSize);
    return 0;
}

A 5

B 6

C 10

D 4

💡 Hint

Count how many unique numbers are in the array.

The unique numbers are 0,1,2,3,4 which are 5 elements, but since indexing starts at 0 and the function returns i+1, the result is 5.

🔧 Debug

advanced

Identify the bug causing incorrect output

The following code is intended to remove duplicates from a sorted array but produces incorrect output. What is the bug?

DSA C

int removeDuplicates(int* nums, int numsSize) {
    int i = 0;
    for (int j = 1; j < numsSize; j++) {
        if (nums[j] != nums[i]) {
            nums[i] = nums[j];
            i++;
        }
    }
    return i;
}

A The assignment nums[i] = nums[j] should happen after incrementing i.

B The function should return i + 1 instead of i.

C The loop should start from j = 0 instead of j = 1.

D The condition nums[j] != nums[i] should be nums[j] == nums[i].

💡 Hint

Check the order of assignment and increment of i.

The code overwrites nums[i] before incrementing i, causing duplicates to be overwritten incorrectly. Incrementing i first then assigning nums[i] = nums[j] fixes the logic.

🧠 Conceptual

advanced

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

Why is the two-pointer technique effective for removing duplicates from a sorted array?

A Because the two pointers count the total number of duplicates without modifying the array.

B Because the two pointers swap elements to sort the array first.

C Because the two pointers create a new array with unique elements.

D Because the array is sorted, duplicates are adjacent, so one pointer can track unique elements while the other scans ahead.

💡 Hint

Think about how sorting affects the position of duplicates.

In a sorted array, duplicates appear next to each other. One pointer keeps track of the last unique element, and the other scans forward to find new unique elements to copy forward.

❓ Predict Output

expert

Output after removing duplicates and printing array

What is the output of the following C code snippet?

DSA C

int removeDuplicates(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    int i = 0;
    for (int j = 1; j < numsSize; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

int main() {
    int nums[] = {2,2,2,3,3,4,5,5,5,6};
    int size = sizeof(nums)/sizeof(nums[0]);
    int newSize = removeDuplicates(nums, size);
    for (int i = 0; i < newSize; i++) {
        printf("%d ", nums[i]);
    }
    return 0;
}

A 2 2 3 3 4 5 5 6

B 2 3 4 5 6

C 2 3 3 4 5 6

D 2 3 4 5 5 6

💡 Hint

Trace how the two pointers move and update the array.

The function removes duplicates by overwriting repeated elements. The final unique elements are 2,3,4,5,6 printed in order.

Practice

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

easy

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

B. To sort the array before removing duplicates

C. To create a new array with unique elements

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

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 directly in the original array.

3. Final Answer:

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

4. Quick Check:

   Two pointers help remove duplicates in-place [OK]

Hint: Two pointers track unique and current elements [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 two pointers i and j for the two-pointer approach in C?

easy

A. int i = 0, j = 1;

B. int i = 1, j = 0;

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

D. int i, j = 0;

Solution

1. Step 1: Understand pointer roles

   Pointer i starts at 0 (first unique), j starts at 1 (scanning next elements).

2. Step 2: Correct initialization syntax

   Both pointers must be initialized properly; int i = 0, j = 1; is correct in C.

3. Final Answer:

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

4. Quick Check:

   Initialize i=0 and j=1 for two-pointer [OK]

Hint: Start i at 0 and j at 1 for scanning [OK]

Common Mistakes:

• Swapping initial values of i and j
• Initializing both pointers to 0
• Incorrect declaration syntax

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

medium

A. 6

B. 5

C. 3

D. 4

Solution

1. Step 1: Trace the two-pointer process

   Start with i=0, j=1. Compare elements: duplicates skipped, unique elements moved forward.

2. Step 2: Count unique elements

   Unique elements are 1, 2, 3, 4. So length is 4 after removal.

3. Final Answer:

   4 -> Option D

4. Quick Check:

   Unique elements count = 4 [OK]

Hint: Count unique elements after skipping duplicates [OK]

Common Mistakes:

• Counting duplicates as unique
• Assuming length stays same
• Miscounting unique elements

4. Identify the bug in this C code snippet for removing duplicates from a sorted array:

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

medium

A. Does not check for array size zero

B. Pointers i and j are initialized incorrectly

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

D. Uses while loop instead of for loop

Solution

1. Step 1: Analyze return value

   Variable i tracks last unique index, so length is i+1, not i.

2. Step 2: Identify correct return

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

3. Final Answer:

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

4. Quick Check:

   Return length = i+1, not i [OK]

Hint: Return last index + 1 for length [OK]

Common Mistakes:

• Off-by-one error in return value
• Ignoring empty array edge case
• Confusing pointer initialization

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, 0, 1, 1, 2, 2, 3, 3, 4, 4]

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

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

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

Solution

1. Step 1: Apply two-pointer overwrite

   Unique elements 0,1,2,3,4 are moved to front positions in array.

2. Step 2: Final array state

   Positions after unique elements remain unchanged or ignored (represented as underscores).

3. Final Answer:

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

4. Quick Check:

   Array front holds unique elements [OK]

Hint: Unique elements overwrite front, rest ignored [OK]

Common Mistakes:

• Assuming duplicates remain in place
• Misplacing unique elements
• Confusing array length with content