Solution 1 - Brute Force (Using a Set)

Create a new list by iterating through the array and only adding elements that haven't been seen before (tracked via a set). Then copy the unique elements back into the original array and return the count.

TimeComplexity: O(n)

SpaceComplexity: O(n)

""" 0026.1 - Remove Duplicates from Sorted Array - Solution 1 - Brute Force (Using a Set) """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def removeDuplicates(self, nums: List[int]) -> int:
        """Remove Duplicates Function"""
        seen = set()
        unique = []

        for num in nums:
            if num not in seen:
                seen.add(num)
                unique.append(num)

        for i in range(len(unique)):
            nums[i] = unique[i]
        return len(unique)


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    nums1 = [1, 1, 2]
    k1 = Solution().removeDuplicates(nums1)
    print(k1, nums1[:k1])  # 2 [1, 2]

    nums2 = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
    k2 = Solution().removeDuplicates(nums2)
    print(k2, nums2[:k2])  # 5 [0, 1, 2, 3, 4]


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

/** 0026.1 - Remove Duplicates from Sorted Array - Solution 1 - Brute Force (Using a Set) */

/////////////////////////////////////////////////////////////////////////////////////
// Classes
/////////////////////////////////////////////////////////////////////////////////////
class Solution {
    /** Remove Duplicates Function */
    removeDuplicates(nums) {
        const seen = new Set();
        const unique = [];

        for (const num of nums) {
            if (!seen.has(num)) {
                seen.add(num);
                unique.push(num);
            }
        }

        for (let i = 0; i < unique.length; i++) {
            nums[i] = unique[i];
        }
        return unique.length;
    }
}


/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
function testcase() {
    /** Test Function */
    const nums1 = [1, 1, 2];
    const k1 = new Solution().removeDuplicates(nums1);
    console.log(k1, nums1.slice(0, k1)); // 2 [1, 2]

    const nums2 = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4];
    const k2 = new Solution().removeDuplicates(nums2);
    console.log(k2, nums2.slice(0, k2)); // 5 [0, 1, 2, 3, 4]
}


/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
testcase();

/** 0026.1 - Remove Duplicates from Sorted Array - Solution 1 - Brute Force (Using a Set) */

/////////////////////////////////////////////////////////////////////////////////////
// Classes
/////////////////////////////////////////////////////////////////////////////////////
class Solution {
    /** Remove Duplicates Function */
    removeDuplicates(nums: number[]): number {
        const seen: Set<number> = new Set();
        const unique: number[] = [];

        for (const num of nums) {
            if (!seen.has(num)) {
                seen.add(num);
                unique.push(num);
            }
        }

        for (let i = 0; i < unique.length; i++) {
            nums[i] = unique[i];
        }
        return unique.length;
    }
}


/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
function testcase(): void {
    /** Test Function */
    const nums1: number[] = [1, 1, 2];
    const k1: number = new Solution().removeDuplicates(nums1);
    console.log(k1, nums1.slice(0, k1)); // 2 [1, 2]

    const nums2: number[] = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4];
    const k2: number = new Solution().removeDuplicates(nums2);
    console.log(k2, nums2.slice(0, k2)); // 5 [0, 1, 2, 3, 4]
}


/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
testcase();

// 0026.1 - Remove Duplicates from Sorted Array - Solution 1 - Brute Force (Using a Set)

package main

/////////////////////////////////////////////////////////////////////////////////////
// Imports
/////////////////////////////////////////////////////////////////////////////////////
import "fmt"

/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
func removeDuplicates(nums []int) int {
	seen := make(map[int]bool)
	unique := []int{}

	for _, num := range nums {
		if !seen[num] {
			seen[num] = true
			unique = append(unique, num)
		}
	}

	for i := 0; i < len(unique); i++ {
		nums[i] = unique[i]
	}
	return len(unique)
}

func testcase() {
	// Test Function
	nums1 := []int{1, 1, 2}
	k1 := removeDuplicates(nums1)
	fmt.Println(k1, nums1[:k1]) // 2 [1 2]

	nums2 := []int{0, 0, 1, 1, 1, 2, 2, 3, 3, 4}
	k2 := removeDuplicates(nums2)
	fmt.Println(k2, nums2[:k2]) // 5 [0 1 2 3 4]
}


/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
func main() {
	testcase()
}

// 0026.1 - Remove Duplicates from Sorted Array - Solution 1 - Brute Force (Using a Set)

use std::collections::HashSet;

/////////////////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////////////////
struct Solution;

/////////////////////////////////////////////////////////////////////////////////////
// Implementations
/////////////////////////////////////////////////////////////////////////////////////
impl Solution {
    /// Remove Duplicates Function
    pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
        let mut seen: HashSet<i32> = HashSet::new();
        let mut unique: Vec<i32> = Vec::new();

        for &num in nums.iter() {
            if !seen.contains(&num) {
                seen.insert(num);
                unique.push(num);
            }
        }

        for i in 0..unique.len() {
            nums[i] = unique[i];
        }
        unique.len() as i32
    }
}

fn main() {
    let mut nums = vec![1, 1, 2];
    let k = Solution::remove_duplicates(&mut nums);
    println!("{} {:?}", k, &nums[..k as usize]);
}

Solution 2 - Two Pointer (Optimal)

Use two pointers: a slow pointer i that tracks the position of the last unique element, and a fast pointer j that scans through the array. When nums[j] differs from nums[i], increment i and overwrite nums[i] with nums[j]. Since the array is sorted, all duplicates are adjacent, so this single pass is sufficient.

TimeComplexity: O(n)

SpaceComplexity: O(1)

""" 0026.2 - Remove Duplicates from Sorted Array - Solution 2 - Two Pointer (Optimal) """

#####################################################################################
# Imports
#####################################################################################
from typing import List

#####################################################################################
# Classes
#####################################################################################
class Solution:
    """Solution Class"""

    def removeDuplicates(self, nums: List[int]) -> int:
        """Remove Duplicates Function"""
        if not nums:
            return 0

        i = 0  # slow pointer — last unique element position
        for j in range(1, len(nums)):
            if nums[j] != nums[i]:
                i += 1
                nums[i] = nums[j]
        return i + 1


#####################################################################################
# Functions
#####################################################################################
def testcase():
    """Test Function"""
    nums1 = [1, 1, 2]
    k1 = Solution().removeDuplicates(nums1)
    print(k1, nums1[:k1])  # 2 [1, 2]

    nums2 = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
    k2 = Solution().removeDuplicates(nums2)
    print(k2, nums2[:k2])  # 5 [0, 1, 2, 3, 4]


#####################################################################################
# Main
#####################################################################################
if __name__ == "__main__":
    testcase()

/** 0026.2 - Remove Duplicates from Sorted Array - Solution 2 - Two Pointer (Optimal) */

/////////////////////////////////////////////////////////////////////////////////////
// Classes
/////////////////////////////////////////////////////////////////////////////////////
class Solution {
    /** Remove Duplicates Function */
    removeDuplicates(nums) {
        if (nums.length === 0) return 0;

        let i = 0;
        for (let j = 1; j < nums.length; j++) {
            if (nums[j] !== nums[i]) {
                i++;
                nums[i] = nums[j];
            }
        }
        return i + 1;
    }
}


/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
function testcase() {
    /** Test Function */
    const nums1 = [1, 1, 2];
    const k1 = new Solution().removeDuplicates(nums1);
    console.log(k1, nums1.slice(0, k1)); // 2 [1, 2]

    const nums2 = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4];
    const k2 = new Solution().removeDuplicates(nums2);
    console.log(k2, nums2.slice(0, k2)); // 5 [0, 1, 2, 3, 4]
}


/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
testcase();

/** 0026.2 - Remove Duplicates from Sorted Array - Solution 2 - Two Pointer (Optimal) */

/////////////////////////////////////////////////////////////////////////////////////
// Classes
/////////////////////////////////////////////////////////////////////////////////////
class Solution {
    /** Remove Duplicates Function */
    removeDuplicates(nums: number[]): number {
        if (nums.length === 0) return 0;

        let i: number = 0;
        for (let j: number = 1; j < nums.length; j++) {
            if (nums[j] !== nums[i]) {
                i++;
                nums[i] = nums[j];
            }
        }
        return i + 1;
    }
}


/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
function testcase(): void {
    /** Test Function */
    const nums1: number[] = [1, 1, 2];
    const k1: number = new Solution().removeDuplicates(nums1);
    console.log(k1, nums1.slice(0, k1)); // 2 [1, 2]

    const nums2: number[] = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4];
    const k2: number = new Solution().removeDuplicates(nums2);
    console.log(k2, nums2.slice(0, k2)); // 5 [0, 1, 2, 3, 4]
}


/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
testcase();

// 0026.2 - Remove Duplicates from Sorted Array - Solution 2 - Two Pointer (Optimal)

package main

/////////////////////////////////////////////////////////////////////////////////////
// Imports
/////////////////////////////////////////////////////////////////////////////////////
import "fmt"

/////////////////////////////////////////////////////////////////////////////////////
// Functions
/////////////////////////////////////////////////////////////////////////////////////
func removeDuplicates(nums []int) int {
	if len(nums) == 0 {
		return 0
	}

	i := 0
	for j := 1; j < len(nums); j++ {
		if nums[j] != nums[i] {
			i++
			nums[i] = nums[j]
		}
	}
	return i + 1
}

func testcase() {
	// Test Function
	nums1 := []int{1, 1, 2}
	k1 := removeDuplicates(nums1)
	fmt.Println(k1, nums1[:k1]) // 2 [1 2]

	nums2 := []int{0, 0, 1, 1, 1, 2, 2, 3, 3, 4}
	k2 := removeDuplicates(nums2)
	fmt.Println(k2, nums2[:k2]) // 5 [0 1 2 3 4]
}


/////////////////////////////////////////////////////////////////////////////////////
// Main
/////////////////////////////////////////////////////////////////////////////////////
func main() {
	testcase()
}

// 0026.2 - Remove Duplicates from Sorted Array - Solution 2 - Two Pointer (Optimal)

/////////////////////////////////////////////////////////////////////////////////////
// Structs
/////////////////////////////////////////////////////////////////////////////////////
struct Solution;

/////////////////////////////////////////////////////////////////////////////////////
// Implementations
/////////////////////////////////////////////////////////////////////////////////////
impl Solution {
    /// Remove Duplicates Function
    pub fn remove_duplicates(nums: &mut Vec<i32>) -> i32 {
        if nums.is_empty() {
            return 0;
        }

        let mut i: usize = 0;
        for j in 1..nums.len() {
            if nums[j] != nums[i] {
                i += 1;
                nums[i] = nums[j];
            }
        }
        (i + 1) as i32
    }
}

fn main() {
    let mut nums = vec![0, 0, 1, 1, 1, 2, 2, 3, 3, 4];
    let k = Solution::remove_duplicates(&mut nums);
    println!("{} {:?}", k, &nums[..k as usize]);
}

0026 - Remove Duplicates from Sorted Array

Solution 1 - Brute Force (Using a Set)

Solution 2 - Two Pointer (Optimal)