Find Words Containing Character - Practice Coding Problems

Find Words Containing Character - Problem

Array String Easy

You are given a 0-indexed array of strings words and a character x.

Return an array of indices representing the words that contain the character x.

Note: The returned array may be in any order.

Input & Output

Example 1 — Basic Case

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

› Output: [0,1,2]

💡 Note: All words contain 'e': "leet" has 'e' at positions 1,2, "code" has 'e' at position 3, "leetcode" has 'e' at positions 1,2,5,6

Example 2 — Some Words Match

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

› Output: [0,2]

💡 Note: Only "abc" (index 0) and "aaaa" (index 2) contain the character 'a'

Example 3 — No Matches

$ Input: words = ["abc","bcd","def"], x = "z"

› Output: []

💡 Note: None of the words contain the character 'z', so return empty array

Constraints

1 ≤ words.length ≤ 50
1 ≤ words[i].length ≤ 50
x is a lowercase English letter
words[i] consists only of lowercase English letters

Visualization

Tap to expand

Understanding the Visualization

Input

Array of words and target character

Process

Check each word for target character

Output

Array of indices where character was found

Key Takeaway

🎯 Key Insight: We must examine every word since any could contain the target character

Asked in

G Google 25 a Amazon 20 M Microsoft 15

The key insight is that we need to check every word for the target character. The best approach uses built-in string contains methods for cleaner, more readable code. Time: O(n×m), Space: O(k) where k is the number of matching words.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Character Check	O(n×m)	O(k)	Check each character in each word manually
Built-in String Contains	O(n×m)	O(k)	Use language built-in string contains/indexOf methods

Brute Force Character Check — Algorithm Steps

Iterate through each word with its index
For each word, check every character
If target character is found, add index to result
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Each Word

Iterate through words array with indices

Check Each Character

For each word, examine every character

Collect Results

Add index when target character is found

Code -

solution.c — C

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

int* solution(char words[][100], int wordsSize, char x, int* returnSize) {
    int* result = malloc(wordsSize * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; j < strlen(words[i]); j++) {
            if (words[i][j] == x) {
                result[(*returnSize)++] = i;
                break;
            }
        }
    }
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for demo - assume max 10 words
    char words[10][100];
    int wordsSize = 0;
    
    char* token = strtok(line, "[],\"\n ");
    while (token != NULL && wordsSize < 10) {
        if (strlen(token) > 0) {
            strcpy(words[wordsSize], token);
            wordsSize++;
        }
        token = strtok(NULL, "[],\"\n ");
    }
    
    char x;
    scanf("%c", &x);
    
    int returnSize;
    int* result = solution(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 words, each with average length m characters to check

✓ Linear Growth

Space Complexity

O(k)

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

✓ Linear Space

21.1K Views

Medium Frequency

~10 min Avg. Time

845 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 Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler