Remove Element - Practice Coding Problems

Remove Element - Problem

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.

Input & Output

Example 1 — Basic Case

$ Input: nums = [3,2,2,3], val = 3

› Output: 2

💡 Note: Remove all occurrences of 3. The first 2 elements become [2,2], so return 2.

Example 2 — No Target Elements

$ Input: nums = [0,1,2,2,3,0,4,2], val = 2

› Output: 5

💡 Note: Remove all occurrences of 2. The first 5 elements become [0,1,3,0,4], so return 5.

Example 3 — All Elements Same

$ Input: nums = [2,2,2], val = 2

› Output: 0

💡 Note: All elements equal the target value, so no elements remain. Return 0.

Constraints

0 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 50
0 ≤ val ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input

Array with some elements equal to target value

Process

Remove all occurrences of target value in-place

Output

Count of remaining elements after removal

Key Takeaway

🎯 Key Insight: Use two pointers to efficiently rearrange elements in-place without extra memory

Asked in

f Facebook 25 G Google 20 A Amazon 15

The key insight is to use two pointers to rearrange elements in-place without extra space. The write pointer tracks where to place the next valid element, while the read pointer scans through the array. Best approach is two pointers with Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Extra Array	O(n)	O(n)	Create new array and copy all non-target elements
Two Pointers - Optimal In-Place	O(n)	O(1)	Use two pointers to rearrange elements in-place without extra space

Brute Force - Extra Array — Algorithm Steps

Create temporary array
Copy all non-target elements
Copy back to original array
Return count

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Array

Input array with target value to remove

Filter & Copy

Create new array, copy non-target elements

Copy Back

Copy filtered elements back to original array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int solution(int* nums, int numsSize, int val) {
    // Create temporary array for non-target elements
    int* temp = (int*)malloc(numsSize * sizeof(int));
    int tempSize = 0;
    
    // Copy all elements that don't equal val
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] != val) {
            temp[tempSize++] = nums[i];
        }
    }
    
    // Copy back to original array
    for (int i = 0; i < tempSize; i++) {
        nums[i] = temp[i];
    }
    
    free(temp);
    // Return count of remaining elements
    return tempSize;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strcmp(token, "\n") != 0 && strlen(token) > 0) {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int val;
    scanf("%d", &val);
    
    int result = solution(nums, numsSize, val);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to filter elements

✓ Linear Growth

Space Complexity

O(n)

Extra array to store filtered elements

⚡ Linearithmic Space

125.0K Views

High Frequency

~15 min Avg. Time

4.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Extra Array — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler