Remove Duplicates From Sorted Array Ii

                                            
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n <= 2) {
            return n;
        }
        
        int index = 2;
        for (int i = 2; i < n; i++) {
            if (nums[i] != nums[index - 2]) {
                nums[index++] = nums[i];
            }
        }
        
        return index;
    }
};

                                            
class Solution {
    public int removeDuplicates(int[] nums) {
        if (nums.length <= 2) {
            return nums.length;
        }
        
        int index = 2;
        for (int i = 2; i < nums.length; i++) {
            if (nums[i] != nums[index - 2]) {
                nums[index] = nums[i];
                index++;
            }
        }
        
        return index;
    }
}

                                            
class Solution(object):
    def removeDuplicates(self, nums):
        if len(nums) <= 2:
            return len(nums)
        
        count = 2
        for i in range(2, len(nums)):
            if nums[i] != nums[count - 2]:
                nums[count] = nums[i]
                count += 1
        
        return count

                                            
int removeDuplicates(int* nums, int numsSize) {
    if (numsSize <= 2) {
        return numsSize;
    }
    
    int index = 2;
    for (int i = 2; i < numsSize; i++) {
        if (nums[i] != nums[index - 2]) {
            nums[index] = nums[i];
            index++;
        }
    }
    
    return index;
}

                                            
public class Solution {
    public int RemoveDuplicates(int[] nums) {
        if (nums.Length <= 2) {
            return nums.Length;
        }
        
        int index = 2;
        for (int i = 2; i < nums.Length; i++) {
            if (nums[i] != nums[index - 2]) {
                nums[index] = nums[i];
                index++;
            }
        }
        
        return index;
    }
}

                                            
/**
 * @param {number[]} nums
 * @return {number}
 */
var removeDuplicates = function(nums) {
    let count = 1;
    let duplicateCount = 1;
    
    for (let i = 1; i < nums.length; i++) {
        if (nums[i] !== nums[i - 1]) {
            nums[count] = nums[i];
            count++;
            duplicateCount = 1;
        } else {
            duplicateCount++;
            if (duplicateCount <= 2) {
                nums[count] = nums[i];
                count++;
            }
        }
    }
    
    return count;
};

                                            
function removeDuplicates(nums: number[]): number {
    let count = 0;
    
    for (let i = 0; i < nums.length; i++) {
        if (count < 2 || nums[i] !== nums[count - 2]) {
            nums[count] = nums[i];
            count++;
        }
    }
    
    return count;
};

                                            
class Solution {
    /**
     * @param Integer[] $nums
     * @return Integer
     */
    function removeDuplicates(&$nums) {
        $n = count($nums);
        if ($n <= 2) {
            return $n;
        }
        
        $index = 2;
        for ($i = 2; $i < $n; $i++) {
            if ($nums[$i] != $nums[$index - 2]) {
                $nums[$index] = $nums[$i];
                $index++;
            }
        }
        
        return $index;
    }
}

                                            
class Solution {
    func removeDuplicates(_ nums: inout [Int]) -> Int {
        if nums.isEmpty {
            return 0
        }
        
        var count = 1
        var isDuplicate = false
        
        for i in 1..<nums.count {
            if nums[i] == nums[i - 1] {
                if !isDuplicate {
                    isDuplicate = true
                    nums[count] = nums[i]
                    count += 1
                }
            } else {
                isDuplicate = false
                nums[count] = nums[i]
                count += 1
            }
        }
        
        return count
    }
}

                                            
class Solution {
    fun removeDuplicates(nums: IntArray): Int {
        if (nums.size <= 2) return nums.size
        
        var index = 2
        
        for (i in 2 until nums.size) {
            if (nums[i] != nums[index - 2]) {
                nums[index] = nums[i]
                index++
            }
        }
        
        return index
    }
}

                                            
class Solution {
  int removeDuplicates(List<int> nums) {
    if (nums.length <= 2) {
      return nums.length;
    }
    
    int index = 2;

    for (int i = 2; i < nums.length; i++) {
      if (nums[i] != nums[index - 2]) {
        nums[index] = nums[i];
        index++;
      }
    }

    return index;
  }
}

                                            
func removeDuplicates(nums []int) int {
    if len(nums) <= 2 {
        return len(nums)
    }
    
    k := 2
    for i := 2; i < len(nums); i++ {
        if nums[i] != nums[k-2] {
            nums[k] = nums[i]
            k++
        }
    }
    
    return k
}

                                            
# @param {Integer[]} nums
# @return {Integer}
def remove_duplicates(nums)
    return 0 if nums.empty?
    
    index = 0
    count = 1
    
    (1..nums.length - 1).each do |i|
        if nums[i] == nums[index]
            count += 1
        else
            count = 1
        end
        
        if count <= 2
            index += 1
            nums[index] = nums[i]
        end
    end
    
    return index + 1
end

                                            
object Solution {
    def removeDuplicates(nums: Array[Int]): Int = {
        if(nums.length <= 2) return nums.length
        var slow = 2
        for(fast <- 2 until nums.length) {
            if(nums(fast) != nums(slow - 2)) {
                nums(slow) = nums(fast)
                slow += 1
            }
        }
        slow
    }
}

                                            
impl Solution {
    pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
        let mut i = 0;
        for j in 0..nums.len() {
            if i < 2 || nums[j] != nums[i - 2] {
                nums[i] = nums[j];
                i += 1;
            }
        }
        i as i32
    }
}

To solve this coding challenge, we need to modify the input array

nums

in-place to ensure that each element appears at most twice while maintaining the order of the elements. The goal is to return the length of the modified array where each unique element appears at most twice.

Explanation

Understanding the Problem :

The input array
nums

is sorted in non-decreasing order.
We need to ensure that no element appears more than two times in the modified array.
The modification should be done in-place, which means we should not use any additional arrays or storage; instead, we should transform
nums

directly.
We need to return the length
k

of the modified array where elements appear at most twice.

Example Analysis :

Example 1: For
nums = [1,1,1,2,2,3]

, the output should be
[1,1,2,2,3, _]

with
k = 5

.
Example 2: For
nums = [0,0,1,1,1,1,2,3,3]

, the output should be
[0,0,1,1,2,3,3,_,_]

with
k = 7

.

Approach :

If the length of
nums

is 2 or less, return the length because such small arrays inherently satisfy the condition.
Use a pointer
count

starting at 2 (because the first two elements are always allowed).
Iterate through the array starting from the third element. If the current element is different from the element
count - 2

positions back, write this element to the position indicated by
count

.
Increment
count

whenever we write a new value, ensuring no element appears more than twice.

Detailed Steps in Pseudocode

Initial Setup :

Check if the length of the array is less than or equal to 2. If true, return the length of the array directly.

Using a Count Pointer :

Initialize
count

to 2.
Iterate over the array starting from index 2.
If the current element is different from the element at
count - 2

, write this element at the
count

position.

Iteration Logic :

For each element starting from index 2, compare it with the element at
count - 2

.
Update the element at
count

and then increment the
count

if the current condition is satisfied.
Continue this process until the end of the array is reached.

Return the Result :

Return the value of
count

which represents the length of the modified array.

Pseudocode

                                            
# Function to remove duplicates from sorted array
function removeDuplicates(nums):

# If the array length is less than or equal to 2, return its length
if length of nums <= 2:
return length of nums  # Array is already valid

# Initialize the pointer for placing non-duplicate elements
count = 2  

# Traverse the array starting from the third element
for i from 2 to length of nums - 1:
# Check if the current element is different from the element `count - 2` positions back
if nums[i] != nums[count - 2]:
# Place the current element at the position `count`
nums[count] = nums[i]  
# Increment the count
count += 1  

# Return the count, which is the length of the modified array
return count

Explanation:

Checking Length :

Before proceeding, we check if the length of
nums

is less than or equal to 2. If it is, we return the same length of
nums

.

Initial Setup :

We start with
count

set to 2 because we allow the first two elements of the array to remain unchanged.

Main Loop :

We iterate from the third element (index 2) to the end of the array.
In the loop, for each element at index
i

, we compare it with the element at
count - 2

.
If they are different, it means that this element can be added to our modified array. We place the element at the position
count

and then increment
count

.

Returning Result :

Finally, we return the value of
count

, which gives the length of the modified array that meets the criteria.

By following this detailed explanation and pseudocode, we can successfully solve the problem of removing duplicates in a sorted array while ensuring each unique element appears no more than twice.