Remove a Character from a String: In-Place, Two-Pointer, Stream

Remove a Character from a String: In-Place, Two-Pointer, and Stream Variants

Removing characters from a string is a foundational interview problem that tests in-place manipulation, two-pointer technique, and the realization that strings are immutable in many languages. The base problem — remove all occurrences of a target character — is simple enough to solve in 30 seconds. Interviewers use it as a warm-up, then push into harder variants: remove duplicates, remove characters matching a set, remove the kth occurrence, or stream-based filtering. This guide covers all the standard variants with working code.

Problem Statement

Given a string s and a character c, return a new string with all occurrences of c removed.

Examples:

• s = "hello world", c = 'l' → "heo word"
• s = "abc", c = 'd' → "abc"
• s = "", any c → ""

Approach 1: List Comprehension / String Builder

Idiomatic in Python: filter and join.

def remove_char(s: str, c: str) -> str:
    """O(n) time, O(n) space — idiomatic Python."""
    return "".join(ch for ch in s if ch != c)


# Equivalent
def remove_char_alt(s: str, c: str) -> str:
    return s.replace(c, "")

str.replace is the practical answer in Python. Complexity: O(n) time, O(n) space (new string).

For interview purposes, write the comprehension version to demonstrate you can solve it manually, then mention replace.

Approach 2: In-Place with Two Pointers (For Mutable Arrays)

If the string is given as a mutable character array (Java, C++, or a list-of-characters in Python), use two pointers to remove in place. Read pointer scans the array; write pointer fills positions to keep.

def remove_char_inplace(chars: list[str], c: str) -> int:
    """Modify chars in place; return new length.
    O(n) time, O(1) extra space."""
    write = 0
    for read in range(len(chars)):
        if chars[read] != c:
            chars[write] = chars[read]
            write += 1
    return write


# Test
chars = list("hello world")
new_len = remove_char_inplace(chars, "l")
print("".join(chars[:new_len]))  # "heo word"

Complexity: O(n) time, O(1) space. The standard answer when interviewers specify “in place” or “no extra string allocation.”

Approach 3: Filter Multiple Characters

Generalize: remove all characters matching a set. Useful follow-up.

def remove_chars(s: str, to_remove: set) -> str:
    """O(n) time, O(n) space."""
    return "".join(ch for ch in s if ch not in to_remove)


# Test
print(remove_chars("hello world", {"l", "o"}))  # "he wrd"

Use set for O(1) lookups. str.translate in Python is the optimized stdlib alternative:

def remove_chars_translate(s: str, to_remove: str) -> str:
    """O(n) time using str.translate."""
    return s.translate(str.maketrans("", "", to_remove))

Approach 4: Remove Duplicates

(LeetCode #316, #1047 — Remove Adjacent Duplicates) Remove consecutive duplicate characters using a stack.

def remove_adjacent_duplicates(s: str) -> str:
    """O(n) time, O(n) space — stack-based."""
    stack = []
    for ch in s:
        if stack and stack[-1] == ch:
            stack.pop()
        else:
            stack.append(ch)
    return "".join(stack)


# Tests
print(remove_adjacent_duplicates("abbaca"))  # "ca"
print(remove_adjacent_duplicates("aaaa"))    # ""

The stack pattern repeatedly cancels adjacent equal characters, naturally handling the “after removal, new adjacencies appear” case.

Approach 5: Stream Filtering

For very large strings or true streaming use cases, generators avoid loading the full string in memory.

def filter_stream(stream, c):
    """Generator that yields characters from stream, skipping c."""
    for ch in stream:
        if ch != c:
            yield ch


# Usage with file streaming
# with open("large.txt") as f:
#     filtered = "".join(filter_stream(f.read(), "l"))

The interview rarely demands streaming, but mentioning the generator approach signals memory awareness.

Common Variations

Remove all whitespace

s.replace(" ", "") for spaces, or "".join(s.split()) to also collapse tabs/newlines. Or use str.translate with a whitespace set.

Remove kth occurrence

Track a counter; remove only when counter matches k. O(n) time.

def remove_kth_occurrence(s: str, c: str, k: int) -> str:
    result = []
    count = 0
    for ch in s:
        if ch == c:
            count += 1
            if count == k:
                continue
        result.append(ch)
    return "".join(result)

Remove all but k occurrences

Variant: keep the first k occurrences, remove the rest. Useful for deduplication-style problems.

Remove according to a predicate

Generalize to any predicate function. Most languages have stdlib filter equivalents (Python’s filter(), JavaScript’s Array.filter(), C++’s std::remove_if).

Sliding window with character removal

(LeetCode #3 — Longest Substring Without Repeating Characters) Different problem family. Sliding window pattern; remove characters from a window, not the string itself.

Common Mistakes

• Treating Python strings as mutable. Strings are immutable; s[i] = "x" raises TypeError. Convert to list, modify, join. Or use the comprehension approach to build a new string.
• Using += in a loop to build the result. In Python, result += ch in a loop is technically O(n²) due to string immutability and reallocation. Use a list with append and join at the end. CPython has internal optimizations that sometimes hide the cost, but the pattern is fragile.
• Off-by-one in the two-pointer in-place version. The write pointer must advance only when the current character is kept; the read pointer always advances. Mixing up these conditions corrupts the output.
• Returning new length but leaving stale data. If the caller uses the array after in-place removal, they should read only up to the returned length. Some implementations zero out the trailing positions; usually unnecessary.
• Confusing “remove all occurrences” with “remove first occurrence.” Read the prompt carefully. str.replace removes all by default; s.replace(c, "", 1) removes only the first.

Frequently Asked Questions

See also: Longest Palindromic Substring • Print String Permutations • Two Sum: Find a Pair in an Array

function removeChar(str, char) {
    const result = [];

    for (let i = 0; i < str.length; i++) {
        if (str[i] !== char) {
            result.push(str[i]);
        }
    }

    return result.join('');
}

// Tests
console.log(removeChar("banana", 'a'));  // "bnn"
console.log(removeChar("hello", 'l'));   // "heo"
console.log(removeChar("aaa", 'a'));     // ""
console.log(removeChar("abc", 'd'));     // "abc"

function removeCharBuiltIn(str, char) {
    // JavaScript replace with regex
    return str.replace(new RegExp(char, 'g'), '');
}

// Or using split/join
function removeCharSplitJoin(str, char) {
    return str.split(char).join('');
}

console.log(removeCharBuiltIn("banana", 'a'));     // "bnn"
console.log(removeCharSplitJoin("banana", 'a'));   // "bnn"

function removeChars(str, charsToRemove) {
    const removeSet = new Set(charsToRemove);
    const result = [];

    for (let i = 0; i < str.length; i++) {
        if (!removeSet.has(str[i])) {
            result.push(str[i]);
        }
    }

    return result.join('');
}

console.log(removeChars("banana", "an"));    // "b"
console.log(removeChars("hello world", "lo")); // "he wrd"

function removeCharInPlace(chars, char) {
    // chars is an array of characters (mutable)
    let writeIndex = 0;

    for (let readIndex = 0; readIndex < chars.length; readIndex++) {
        if (chars[readIndex] !== char) {
            chars[writeIndex] = chars[readIndex];
            writeIndex++;
        }
    }

    // Truncate array or mark end
    chars.length = writeIndex;
    return chars;
}

// Test
const chars = ['b', 'a', 'n', 'a', 'n', 'a'];
removeCharInPlace(chars, 'a');
console.log(chars);  // ['b', 'n', 'n']

Initial: ['b', 'a', 'n', 'a', 'n', 'a']
         read=0, write=0

read=0: 'b' !== 'a', write 'b' at 0, write++
        ['b', 'a', 'n', 'a', 'n', 'a']
         read=1, write=1

read=1: 'a' === 'a', skip
        read=2, write=1

read=2: 'n' !== 'a', write 'n' at 1, write++
        ['b', 'n', 'n', 'a', 'n', 'a']
         read=3, write=2

read=3: 'a' === 'a', skip
        read=4, write=2

read=4: 'n' !== 'a', write 'n' at 2, write++
        ['b', 'n', 'n', 'a', 'n', 'a']
         read=5, write=3

read=5: 'a' === 'a', skip
        read=6, write=3

Result: ['b', 'n', 'n'] (length = 3)

function removeCharCaseInsensitive(str, char) {
    const lowerChar = char.toLowerCase();
    const result = [];

    for (let i = 0; i < str.length; i++) {
        if (str[i].toLowerCase() !== lowerChar) {
            result.push(str[i]);
        }
    }

    return result.join('');
}

console.log(removeCharCaseInsensitive("BaNaNa", 'a'));  // "BNN"