---
# System prepended metadata

title: '[26. Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/)'
tags: [Array, easy, leetcode, Two Pointers]

---

###### tags: `leetcode` `easy` `Array` `Two Pointers`
# [26. Remove Duplicates from Sorted Array](https://leetcode.com/problems/remove-duplicates-from-sorted-array/)

## Description

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

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. It does not matter what you leave beyond the first `k` elements.  

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.

## Custom Judge:

The judge will test your solution with the following code:

```c
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**.

## Examples
### Example 1:

- **Input**: nums = [1,1,2]  
- **Output**: 2, nums = [1,2,_]  
- **Explanation**: 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 (hence they are underscores).

### Example 2:

- **Input**: nums = [0,0,1,1,1,2,2,3,3,4]  
- **Output**: 5, nums = [0,1,2,3,4,_,_,_,_,_]  
- **Explanation**: Your function should return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4 respectively.  
It does not matter what you leave beyond the returned k (hence they are underscores).

## Constraints:

- $1 \leq nums.length \leq 3 \times 10^4$  
- $-100 \leq nums[i] \leq 100$  
- `nums` is sorted in **non-decreasing** order.

## Code

```c=
int removeDuplicates(int* nums, int numsSize){
    if(numsSize == 0)
        return 0;
    int valiNum = 1, i = 1;
    for( ; i < numsSize ; i++ ){
        if(nums[i] == nums[i-1])
            continue;
        nums[valiNum] = nums[i];
        valiNum++;
    }
    return valiNum;
}
```

## Complexity

|Space |Time  |
|-     |-     |
|$O(1)$|$O(N)$|

## Result

- Runtime: 32 ms, faster than 22.02%  
- Memory Usage: 7.4 MB, less than 98.34%
