Remove Duplicates from Sorted Array II

Remove Duplicates from Sorted Array II - Problem

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

Since it is impossible to change the length of the array in some languages, you must instead have the result be placed in the first part of the array nums. More formally, if there are k elements after removing the duplicates, then the first k elements of nums should hold the final result.

Return k after placing the final result in the first k slots of nums. Do not allocate extra space for another array. You must do this by modifying the input array in-place with O(1) extra memory.

Input & Output

Example 1 — Multiple Duplicates

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

› Output: 5

💡 Note: Remove one duplicate '1' to get [1,1,2,2,3]. Return length 5. Final array: [1,1,2,2,3,3] where we only consider first 5 elements.

Example 2 — Some Triples

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

› Output: 7

💡 Note: Remove duplicates to get [0,0,1,1,2,3,3]. Two 0s, two 1s, one 2, two 3s - all ≤ 2 occurrences each.

Example 3 — No Excess Duplicates

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

› Output: 3

💡 Note: No element appears more than twice, so keep all elements. Return length 3.

Constraints

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

Visualization

Tap to expand

Asked in

M Microsoft 25 a Amazon 20 f Facebook 15 G Google 12

The key insight is to use two pointers where we compare each element with the element 2 positions back in our result. This automatically ensures each unique element appears at most twice. Best approach is the two-pointer technique with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Count Duplicates

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

Iterate through the array and for each element, count its occurrences in the portion we've already processed. If count is less than 2, keep the element.

Two Pointers - Optimal Solution

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

Maintain a write pointer for the next position to place an element. For each element, only place it if it's different from the element 2 positions back in the result array.

Brute Force - Count Duplicates — Algorithm Steps

For each element, scan all previous elements
Count occurrences of current element
Keep element only if count < 2
Shift remaining elements when removing

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Element

For current element, scan all previous processed elements

Count Matches

Count how many times current element appears before

Keep or Skip

If count < 2, keep element; otherwise skip it

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    if (numsSize <= 2) return numsSize;
    
    int writeIdx = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int count = 0;
        // Count occurrences in result portion
        for (int j = 0; j < writeIdx; j++) {
            if (nums[j] == nums[i]) {
                count++;
            }
        }
        
        // Keep element if count < 2
        if (count < 2) {
            nums[writeIdx] = nums[i];
            writeIdx++;
        }
    }
    
    return writeIdx;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for array format [1,2,3]
    int nums[10000];
    int numsSize = 0;
    
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element, we scan all previous elements to count occurrences

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and indexing

✓ Linear Space

85.0K Views

Medium Frequency

~15 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Count Duplicates — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler