27. Remove Element

Given an integer array nums and an integer val, remove all occurrences of val in nums in-place. The order of the elements may be changed. Then return the number of elements in nums which are not equal to val.

Consider the number of elements in nums which are not equal to val 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 elements which are not equal to val. The remaining elements of nums are not important as well as the size of nums.
Return k.

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

Constraints:

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

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        left = 0
        right = len(nums) - 1
        
        while left <= right:
            if nums[left] == val:
                nums[left], nums[right] = nums[right], nums[left]
                right -= 1
            else:
                left += 1
        
        return left
        

This code uses two pointers, left and right, to partition the array into two parts. The first part contains elements that are not equal to val, while the second part contains val.

We iterate through the array using left pointer and if we encounter an element equal to val, we swap it with the element at right pointer and move right pointer to the left. If the element is not equal to val, we simply move left pointer to the right.

Finally, we return the value of left, which represents the number of elements in the array that are not equal to val.

Initialization: The left pointer is initialized to 0, and the right pointer is initialized to the last index of the array (len(nums) - 1).

Loop Condition: The loop continues as long as left is less than or equal to right. This ensures that we are processing elements within the valid range.

If Statement (Condition for Swapping): Inside the loop, there is an if statement checking whether the element at the left index is equal to the given value val. If it is, the elements at the left and right indices are swapped, and the right pointer is decremented by 1. This step essentially moves the element equal to val to the end of the array.

Else Statement (Moving Non-val Elements): If the element at the left index is not equal to val, the left pointer is incremented by 1. This step moves the pointer to the next element in the array.

Termination Condition: The loop continues until the left pointer is greater than the right pointer, indicating that the processing of elements is complete.

Return Statement: The function returns the value of left after the loop, which represents the number of elements in the modified array that are not equal to val.

In summary, the loop effectively partitions the array into two regions: elements not equal to val on the left side (from index 0 to left-1), and elements equal to val on the right side (from right+1 to the end). The left pointer keeps track of the boundary between these two regions. The function then returns the count of elements on the left side, which are the elements not equal to val.