Remove Duplicates from Sorted Array

Remove Duplicates from Sorted Array - Problem

Given an integer array nums sorted in non-decreasing order, remove the duplicates in-place such that each unique element appears only once. The relative order of the elements should be kept the same.

Consider the number of unique elements in nums to be k. After removing duplicates, return the number of unique elements k. The first k elements of nums should contain the unique numbers in sorted order. The remaining elements beyond index k-1 can be ignored.

Custom Judge: The judge will test your solution with the following code:

int[] nums = [...]; // Input array
int[] expectedNums = [...]; // The expected answer with correct length
int k = removeDuplicates(nums); // Calls your implementation

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

If all assertions pass, then your solution will be accepted.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Your function should return k = 2, with the first two elements of nums being 1 and 2 respectively. It does not matter what you leave beyond the returned k.

Example 2 — Multiple Duplicates

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

› Output: 5

💡 Note: Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.

Example 3 — Single Element

$ Input: nums = [1]

› Output: 1

💡 Note: Single element array has no duplicates, return 1.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 35 f Facebook 28

The key insight is that since the array is sorted, all duplicate elements are adjacent to each other. The optimal approach uses two pointers - one to scan through the array and another to track where to place the next unique element. This achieves O(n) time and O(1) space complexity while modifying the array in-place.

Common Approaches

✓ Brute Force - Check All Pairs

⏱️ Time: O(n²) Space: O(n)

Iterate through each element and compare it with all previous elements to see if it's a duplicate. If it's not a duplicate, keep it in the result.

Two Pointers - Optimal In-Place

⏱️ Time: O(n) Space: O(1)

Since the array is sorted, duplicates are adjacent. Use one pointer to track where to place the next unique element, and another to iterate through the array.

Brute Force - Check All Pairs — Algorithm Steps

Step 1: For each element at position i
Step 2: Check all elements from 0 to i-1
Step 3: If no match found, add to result array
Step 4: Return count of unique elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare Element

For each element, check all previous positions

Find Duplicates

If element exists before, mark as duplicate

Keep Unique

Only add elements that haven't been seen

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    int* unique = (int*)malloc(numsSize * sizeof(int));
    int uniqueSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int isDuplicate = 0;
        for (int j = 0; j < i; j++) {
            if (nums[i] == nums[j]) {
                isDuplicate = 1;
                break;
            }
        }
        if (!isDuplicate) {
            unique[uniqueSize++] = nums[i];
        }
    }
    
    // Copy unique elements back to original array
    for (int i = 0; i < uniqueSize; i++) {
        nums[i] = unique[i];
    }
    
    free(unique);
    return uniqueSize;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    if (strcmp(line, "[]\n") == 0) {
        printf("0\n");
        return 0;
    }
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops - for each of n elements, check up to n previous elements

✓ Linear Growth

Space Complexity

O(n)

Need extra array to store unique elements

✓ Linear Space

67.2K Views

High Frequency

~15 min Avg. Time

1.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler