NYUer | LeetCode27 Remove Element

LeetCode27 Remove Element

---

Author: Stefan Su
Create time: 2022-10-26 02:59:56
Location: New York City, NY, USA

Description Easy

Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The relative order of the elements may be changed.

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.

Example 1

Input: nums = [3,2,2,3], val = 3
Output: 2, nums = [2,2,_,_]
Explanation: Your function should return k = 2, with the first two elements of nums being 2.
It does not matter what you leave beyond the returned k (hence they are underscores).

Example 2

Input: nums = [0,1,2,2,3,0,4,2], val = 2
Output: 5, nums = [0,1,4,0,3,_,_,_]
Explanation: Your function should return k = 5, with the first five elements of nums 
			 containing 0, 0, 1, 3, and 4.
Note that the five elements can be returned in any order.
It does not matter what you leave beyond the returned k (hence they are underscores).

Constrains

• 0 <= nums.length <= 100
• 0 <= nums[i] <= 50
• 0 <= val <= 100

Analysis

The key to this problem is operating in the original array by using two indices, fast_index and slow_index. fast_index is used to go through the whole array to find val and slow_index is used to rewrite this array. Every time fast_index encounters val, it will check whether it is equal to val and go to the next index. If they are equal, only fast_index move ahead to next index, and slow_index stops. If not, we do assignment operation, that is copying the number at fast_index to current slow_index position.

Generally speaking, I believe this problem is all about skipping the val and copy from later array to cover current position.

Solution

• python built-in version

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        # use built-in funtion in python
        while val in nums:
            nums.remove(val)
        return len(nums)

• slow_index and fast_index version

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        # use slow_index and fast_index
        slow = 0
        for fast in range(len(nums)):
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
        return slow

Hopefully, this blog can inspire you when solving LeetCode27. For any questions, please comment below.