# LeetCode: 26. Remove Duplicates from Sorted Array

**The Problem**

Given an integer array `nums`

sorted in ** non-decreasing order**, remove the duplicates

**such that each unique element appears only**

**in-place****. The**

**once****of the elements should be kept the**

**relative order****. Then return**

**same***the number of unique elements in*

`nums`

.Consider the number of unique elements of `nums`

to be `k`

, to get accepted, you need to do the following things:

- Change the array
`nums`

such that the first`k`

elements of`nums`

contain the unique elements in the order they were present in`nums`

initially. The remaining elements of`nums`

are not important as well as the size of`nums`

. - Return
`k`

.

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

**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 <= nums.length <= 3 * 10`

^{4}`-100 <= nums[i] <= 100`

`nums`

is sorted inorder.**non-decreasing**

**The Solution**

We opted for a simple approach using a **for** loop

```
int removeDuplicates(vector<int>& nums) {
int lastNonDuplicate = 1;
for(int i = 1; i < nums.size(); ++i){
lastNonDuplicate += ( nums[i] != nums[i - 1]);
nums[lastNonDuplicate - 1] = nums[i];
}
return lastNonDuplicate;
}
```

ðŸ§

Github with all the solution including test cases.

**Explanation:**

- The function
`removeDuplicates`

takes a reference to a sorted vector of integers as its parameter. - It iterates through the array, keeping track of the last index where a non-duplicate element should be placed.
- If the current element is different from the previous one, it updates the
`lastNonDuplicate`

index. - It overwrites duplicates with non-duplicate elements in-place.
- Finally, it returns the count of unique elements.

This approach achieves removal of duplicates in linear time complexity, making it efficient for large arrays.