Remove Element

                                            
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int k = 0;
        for (int i = 0; i < nums.size(); ++i) {
            if (nums[i] != val) {
                nums[k++] = nums[i];
            }
        }
        return k;
    }
};

                                            
class Solution {
    public int removeElement(int[] nums, int val) {
        int k = 0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != val) {
                nums[k] = nums[i];
                k++;
            }
        }
        return k;
    }
}

                                            
class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        k = 0
        for num in nums:
            if num != val:
                nums[k] = num
                k += 1
        return k

                                            
int removeElement(int* nums, int numsSize, int val) {
    int k = 0;
    for(int i = 0; i < numsSize; i++) {
        if(nums[i] != val) {
            nums[k] = nums[i];
            k++;
        }
    }
    return k;
}

                                            
public class Solution {
    public int RemoveElement(int[] nums, int val) {
        int k = 0;
        for (int i = 0; i < nums.Length; i++) {
            if (nums[i] != val) {
                nums[k] = nums[i];
                k++;
            }
        }
        return k;
    }
}

                                            
/**
 * @param {number[]} nums
 * @param {number} val
 * @return {number}
 */
var removeElement = function(nums, val) {
    let k = 0;
    
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== val) {
            nums[k] = nums[i];
            k++;
        }
    }
    
    return k;
};

                                            
function removeElement(nums: number[], val: number): number {
    let k = 0;
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] !== val) {
            nums[k] = nums[i];
            k++;
        }
    }
    return k;
};

                                            
class Solution {
    /**
     * @param Integer[] $nums
     * @param Integer $val
     * @return Integer
     */
    function removeElement(&$nums, $val) {
        $k = 0;
        foreach($nums as $num){
            if($num != $val){
                $nums[$k++] = $num;
            }
        }
        return $k;
    }
}

                                            
class Solution {
    func removeElement(_ nums: inout [Int], _ val: Int) -> Int {
        var k = 0
        for i in 0..<nums.count {
            if nums[i] != val {
                nums[k] = nums[i]
                k += 1
            }
        }
        return k
    }
}

                                            
class Solution {
    fun removeElement(nums: IntArray, `val`: Int): Int {
        var k = 0
        for (num in nums) {
            if (num != `val`) {
                nums[k] = num
                k++
            }
        }
        return k
    }
}

To solve this coding challenge, we aim to remove all occurrences of a specified value,

val

, from an integer array,

nums

, in-place and return the count of elements that are not equal to

val

. The key criteria are modifying the input array so that the first

k

elements are those that are not equal to

val

and ensuring that

k

is correctly calculated.

Explanation

The task is to filter out the elements equal to

val

from the array

nums

and return the length of the filtered array. The elements that are not equal to

val

should appear in the first

k

positions of the

nums

array. The order of non-

val

elements in the modified array does not matter. Given the constraints:

The length of
nums

is between 0 and 100.
The value of
nums[i]

is between 0 and 50.
The value of
val

is between 0 and 100.

These constraints imply that the problem can be solved efficiently with a single pass through the array.

Step-by-Step Explanation

Initialization : Begin by initializing a counter
k

to zero. This counter will keep track of the position to place the next non-
val

element.
Traversal and Filtering : Iterate through each element in the array
nums

.

If the current element is not equal to
val

, place this element at the index indicated by
k

and then increment
k

.
If the current element equals
val

, continue to the next element without incrementing
k

.

Result : After completing the iteration through the array, the first
k

elements of
nums

will be the elements that are not equal to
val

. The variable
k

will represent the number of these elements.
Return : Return
k

, the count of elements that are not equal to
val

.

Below is a pseudocode representation of this approach:

                                            
// Initialize a counter to track the position of the non-val elements
Initialize count_non_val_elements to 0

// Iterate through all elements in the nums array
For each element in nums:
// If the current element is not equal to val
If element is not equal to val:
// Place this element at the next available position in the array
nums[count_non_val_elements] = element
// Increment the counter
Increment count_non_val_elements

// Return the count of non-val elements
Return count_non_val_elements

Detailed Steps in Pseudocode

Initialize a counter :

                                            
count_non_val_elements = 0 // This will count the valid elements

Loop through the array :

                                            
For each element in nums:
If element != val:
nums[count_non_val_elements] = element // Place valid element at the counted position
count_non_val_elements += 1 // Increment the counter for valid elements

Return the count :

                                            
Return count_non_val_elements

This pseudocode outlines how to iterate through the array only once, making the time complexity O(n), where

n

is the length of the array. It also ensures that we do not use extra space, other than a few scalar variables, adhering to an O(1) space complexity. By following this approach, we can ensure that the function performs efficiently within the given constraints and meets all the problem's requirements.