Medium Difficulty
Remove Duplicates from Sorted Array Ii

Array

Tow Pointers

medium

Remove Duplicates from Sorted Array II

To solve this problem in JavaScript, you can use the two-pointer approach to modify the array in-place.

• Handle the edge case where the array is empty by returning 0.

• Initialize the variables: count to keep track of the count of unique elements, duplicateCount to keep track of the count of duplicates (initialized as 1 since the first element is unique), and prev to store the value of the previous element.

• Iterate through the array starting from the second element (index 1). If the current element is equal to the previous element, check if the duplicates count is less than 2. If so, it means we can include the current element as a duplicate. Move the element to the next unique position by assigning it to nums[count], increment count to account for the new unique element, and increment duplicateCount.

• If the current element is different from the previous element, it means we have encountered a new unique element. Move the element to the next unique position by assigning it to nums[count], increment count to account for the new unique element, reset duplicateCount to 1 since the current element is the first occurrence, and update prev to the current element.

• After the loop ends, return the value of count, which represents the count of unique elements in the modified array.

``````function removeDuplicates(nums) {
// Edge case: If the array is empty, return 0
if (nums.length === 0) {
return 0;
}

// Initialize variables
let count = 1; // Count of unique elements
let duplicateCount = 1; // Count of duplicates
let prev = nums[0]; // Previous element

// Iterate from the second element onwards
for (let i = 1; i < nums.length; i++) {
// If the current element is equal to the previous element
if (nums[i] === prev) {
// If duplicates count is less than or equal to 2
if (duplicateCount < 2) {
nums[count] = nums[i]; // Move the element to the next unique position
count++; // Increment count of unique elements
duplicateCount++; // Increment duplicates count
}
}
// If the current element is different from the previous element
else {
nums[count] = nums[i]; // Move the element to the next unique position
count++; // Increment count of unique elements
duplicateCount = 1; // Reset duplicates count
prev = nums[i]; // Update the previous element
}
}

return count; // Return the count of unique elements
}``````

The array nums will be modified in-place, and the first count elements will hold the final result. Any elements beyond the first count elements can have any arbitrary values and are not considered part of the solution.

The time complexity of this solution is O(n), where n is the length of the `nums` array. This is because we iterate through the array once, comparing each element with the previous element.

The space complexity is O(1) because we are modifying the `nums` array in-place and using a constant amount of extra memory for the variables `count`, `duplicateCount`, and `prev`. We are not allocating any additional data structures that scale with the input size.