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.