Find Words Containing Character - Practice Coding Problems

Find Words Containing Character - Problem

Array String Easy

You're working as a content moderator and need to quickly identify words that contain a specific character. Given a 0-indexed array of strings words and a target character x, your task is to return an array of indices representing all words that contain the character x.

Goal: Find all word positions that contain the target character

Input: An array of strings and a single character

Output: Array of indices (positions) where the character appears

Note: The returned array can be in any order, making this problem flexible for optimization!

Example: If words = ["hello", "world", "leetcode"] and x = "l", return [0, 1, 2] because all three words contain the letter 'l'.

Input & Output

example_1.py — Basic Case

$ Input: words = ["leet", "code"], x = "e"

› Output: [0]

💡 Note: Only the word "leet" at index 0 contains the character 'e'. The word "code" does not contain 'e'.

example_2.py — Multiple Matches

$ Input: words = ["hello", "world", "leetcode"], x = "o"

› Output: [1, 2]

💡 Note: Words "world" (index 1) and "leetcode" (index 2) contain the character 'o'. "hello" does not contain 'o'.

example_3.py — All Match

$ Input: words = ["abc", "bcd", "aaaa", "cbc"], x = "a"

› Output: [0, 2]

💡 Note: Words at indices 0 ("abc") and 2 ("aaaa") contain the character 'a'. Words "bcd" and "cbc" do not contain 'a'.

Constraints

1 ≤ words.length ≤ 50
1 ≤ words[i].length ≤ 50
x is a single character
words[i] and x consist of only lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Start with first folder

Check if 'hello' contains 'l' → Yes, mark index 0

Check next folder

Check if 'world' contains 'l' → Yes, mark index 1

Continue systematically

Check if 'leetcode' contains 'l' → Yes, mark index 2

Collect results

Return all marked indices: [0, 1, 2]

Key Takeaway

🎯 Key Insight: This problem is straightforward - iterate once through the array and use built-in string search methods. No complex algorithms needed!

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 f Meta 4

The optimal solution uses a single pass through the array with built-in string search methods. For each word, check if it contains the target character using in (Python), includes() (JavaScript), or indexOf() (Java). This approach is clean, efficient, and leverages optimized built-in functions for the best balance of readability and performance.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character-by-Character)	O(n * m)	O(k)	Check each character in each word manually
One-Pass Built-in Search (Optimal)	O(n * m)	O(k)	Use built-in string contains method for efficient searching

Brute Force (Character-by-Character) — Algorithm Steps

Initialize empty result array
Loop through each word with its index
For each word, loop through each character
If target character found, add index to result and break
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first word

Begin checking characters in 'hello'

Check each character

h ≠ l, e ≠ l, l = l ✓ Found! Add index 0

Move to next word

Check 'world': w ≠ l, o ≠ l, r ≠ l, l = l ✓ Add index 1

Continue pattern

Repeat for all remaining words

Code -

solution.c — C

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

int* findWordsContaining(char** words, int wordsSize, char x, int* returnSize) {
    int* result = (int*)malloc(wordsSize * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        int found = 0;
        
        // Check each character in the word
        for (int j = 0; j < strlen(words[i]); j++) {
            if (words[i][j] == x) {
                found = 1;
                break;
            }
        }
        
        if (found) {
            result[count++] = i;
        }
    }
    
    *returnSize = count;
    return result;
}

int main() {
    char* words[] = {"hello", "world", "leetcode"};
    int wordsSize = 3;
    char x = 'l';
    int returnSize;
    
    int* result = findWordsContaining(words, wordsSize, x, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n is number of words, m is average length of words. We check each character in each word.

✓ Linear Growth

Space Complexity

O(k)

k is the number of words containing the target character (for the result array)

✓ Linear Space

28.4K Views

Medium Frequency

~8 min Avg. Time

892 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 (Character-by-Character) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler