Remove Duplicates from Sorted Array - Practice Coding Problems

Remove Duplicates from Sorted Array - Problem

You're given a sorted array of integers that may contain duplicates. Your task is to remove duplicates in-place so that each unique element appears only once, while maintaining the original sorted order.

The challenge is to do this without using extra space for another array. Instead, you need to modify the original array and return the number of unique elements.

Important: You don't need to worry about elements beyond the first k positions (where k is the number of unique elements). The judge will only check the first k elements of your modified array.

Example: If you have [1,1,2,2,3], you should modify it to [1,2,3,_,_] and return 3. The underscores represent elements that can be ignored.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,1,2]

› Output: 2, nums = [1,2,_]

💡 Note: The function returns 2 since there are two unique elements: 1 and 2. The array is modified to [1,2,_] where _ represents elements that can be ignored.

example_2.py — Multiple Duplicates

$ Input: nums = [0,0,1,1,1,2,2,3,3,4]

› Output: 5, nums = [0,1,2,3,4,_,_,_,_,_]

💡 Note: There are five unique elements: 0, 1, 2, 3, and 4. After removing duplicates in-place, the first 5 positions contain these unique elements in sorted order.

example_3.py — Edge Case

$ Input: nums = [1]

› Output: 1, nums = [1]

💡 Note: Single element array has only one unique element, so the array remains unchanged and function returns 1.

Visualization

Tap to expand

Understanding the Visualization

Setup Bookmarks

Place 'slow' bookmark at position 1 (first book is always kept). 'Fast' bookmark scans all books.

Compare Titles

Compare book at fast bookmark with the last unique book placed (at slow-1).

Place Unique Books

If titles are different, move the book to slow position and advance slow bookmark.

Continue Process

Keep scanning with fast bookmark until all books are checked.

Key Takeaway

🎯 Key Insight: Since the array is sorted, duplicates are always adjacent! We only need to compare each element with the previous unique element we've placed, making this an O(n) single-pass solution.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no extra data structures

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-100 ≤ nums[i] ≤ 100
nums is sorted in non-decreasing order

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses two pointers to efficiently remove duplicates in O(n) time. Since the array is sorted, duplicates are adjacent, so we only need to compare each element with the previous unique element. The slow pointer tracks where to place the next unique element, while the fast pointer scans through the array. This approach achieves O(1) space complexity by modifying the array in-place.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use slow and fast pointers to track unique elements efficiently
Brute Force (Nested Loops)	O(n²)	O(1)	For each position, scan ahead to find the next different element

Two Pointers (Optimal) — Algorithm Steps

Initialize slow pointer at index 1 (first element is always unique)
Use fast pointer to iterate through array starting from index 1
Compare element at fast pointer with element at (slow-1) position
If different, copy fast pointer element to slow position and increment slow
Continue until fast pointer reaches end, return slow as count of unique elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Slow=1, Fast=1. First element always unique.

Compare Elements

Compare nums[fast] with nums[slow-1]

Place Unique

If different, copy to slow position and increment slow

Continue Scanning

Move fast pointer and repeat until end

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

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

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int sign = 1;
    int reading_num = 0;
    
    while (scanf("%c", &c) == 1) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            reading_num = 1;
        } else if (c == '-' && !reading_num) {
            sign = -1;
        } else {
            if (reading_num) {
                nums[size++] = num * sign;
                num = 0;
                sign = 1;
                reading_num = 0;
            }
            if (c == ']') break;
        }
    }
    
    printf("%d\n", removeDuplicates(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with two pointers

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no extra data structures

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
-100 ≤ nums[i] ≤ 100
nums is sorted in non-decreasing order

95.2K Views

Very High Frequency

~15 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler