Remove Element - Practice Coding Problems

Remove Element - Problem

Remove Element In-Place

You're given an integer array nums and a target value val. Your mission is to remove all occurrences of val from the array in-place and return the count of remaining elements.

🎯 The Challenge:
• Modify the array directly (no extra array allowed)
• The order of remaining elements can be changed
• Return k = number of elements that are NOT equal to val
• The first k elements should contain all the valid elements

Example: If nums = [3,2,2,3] and val = 3, after removal you should have [2,2,_,_] and return k = 2.

Note: The elements after position k don't matter - they can be anything!

Input & Output

example_1.py — Python

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

› Output: 2

💡 Note: Remove all occurrences of 3. The array becomes [2,2,_,_] where underscores represent irrelevant values. Return k=2 since there are 2 elements not equal to 3.

example_2.py — Python

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

› Output: 5

💡 Note: Remove all occurrences of 2. The array becomes [0,1,4,0,3,_,_,_]. Return k=5 since there are 5 elements not equal to 2.

example_3.py — Python

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

› Output: 0

💡 Note: The single element equals val, so remove it. The array becomes [_] and return k=0 since no elements remain.

Visualization

Tap to expand

Understanding the Visualization

Setup

Place two bookmarks: 'reader' at start, 'writer' at start

Scan

Reader checks each book - is it the genre we want to remove?

Keep Good Books

If book is good, move it to writer position and advance writer

Skip Bad Books

If book is target genre, just move reader (don't advance writer)

Result

Writer position shows count of books kept

Key Takeaway

🎯 Key Insight: Use two pointers to avoid expensive shifting operations - just overwrite unwanted elements with valid ones!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables

✓ Linear Space

Constraints

0 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
-100 ≤ val ≤ 100
Must modify array in-place

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses the two pointers technique with O(n) time and O(1) space. Use a write pointer to track valid element positions and a read pointer to scan the array. Copy non-target elements to write positions.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use read and write pointers to overwrite array in-place
Brute Force (Remove and Shift)	O(n²)	O(1)	Find target elements and shift array left each time

Two Pointers (Optimal) — Algorithm Steps

Initialize write pointer at index 0
Use read pointer to iterate through entire array
When read pointer finds non-target element, copy it to write position
Increment write pointer only when copying elements
Return write pointer value as the count of valid elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set write=0, read starts at 0

Read Element

Check if current element equals target

Copy if Valid

If not target, copy to write position and increment write

Continue

Move read pointer and repeat until end

Code -

solution.c — C

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

int removeElement(int* nums, int numsSize, int val) {
    int write = 0; // Write pointer for valid elements
    
    // Read pointer iterates through all elements
    for (int read = 0; read < numsSize; read++) {
        // If current element is not the target value
        if (nums[read] != val) {
            nums[write] = nums[read]; // Copy to write position
            write++; // Move write pointer forward
        }
    }
    
    return write; // Number of valid elements
}

int main() {
    int nums[1000];
    int val;
    int size = 0;
    
    // Simple input parsing
    char ch;
    while ((ch = getchar()) != '[') ; // Skip to first [
    
    while (scanf("%d", &nums[size]) == 1) {
        size++;
        ch = getchar();
        if (ch == ']') break;
    }
    
    scanf(", %d", &val);
    
    int result = removeElement(nums, size, val);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array with constant work per element

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables

✓ Linear Space

Constraints

0 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
-100 ≤ val ≤ 100
Must modify array in-place

89.0K Views

Very High Frequency

~15 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler