Find Words Containing Character

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

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

✓ Brute Force Character Check

⏱️ Time: O(n×m) Space: O(k)

Iterate through each word and manually check every character to see if it matches the target character. When found, add the word's index to the result array.

Built-in String Contains

⏱️ Time: O(n×m) Space: O(k)

Leverage the built-in string search functions provided by each programming language. These are typically optimized at the language level and are more readable than manual character checking.

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>
#include <stdbool.h>

typedef struct {
    int* freq;
} FreqArray;

typedef struct {
    FreqArray* arrays;
    int count;
    int capacity;
} Result;

bool isSubsequence(const char* word, const char* seq) {
    int i = 0;
    int wordLen = strlen(word);
    
    for (int j = 0; seq[j]; j++) {
        if (i < wordLen && seq[j] == word[i]) {
            i++;
        }
    }
    return i == wordLen;
}

bool isValidSupersequence(const char* seq, char** words, int wordCount) {
    for (int i = 0; i < wordCount; i++) {
        if (!isSubsequence(words[i], seq)) {
            return false;
        }
    }
    return true;
}

int* getFrequency(const char* s) {
    int* freq = (int*)calloc(26, sizeof(int));
    for (int i = 0; s[i]; i++) {
        freq[s[i] - 'a']++;
    }
    return freq;
}

bool isDuplicate(Result* result, int* freq) {
    for (int i = 0; i < result->count; i++) {
        bool same = true;
        for (int j = 0; j < 26; j++) {
            if (result->arrays[i].freq[j] != freq[j]) {
                same = false;
                break;
            }
        }
        if (same) return true;
    }
    return false;
}

void generateSupersequences(char** words, int wordCount, char* current, int pos, 
                           int targetLen, Result* result) {
    if (pos > targetLen + 3) return;
    
    current[pos] = '\0';
    if (isValidSupersequence(current, words, wordCount)) {
        if (pos <= targetLen + 3) {
            int* freq = getFrequency(current);
            if (!isDuplicate(result, freq)) {
                if (result->count >= result->capacity) {
                    result->capacity *= 2;
                    result->arrays = realloc(result->arrays, result->capacity * sizeof(FreqArray));
                }
                result->arrays[result->count].freq = freq;
                result->count++;
            } else {
                free(freq);
            }
        }
        return;
    }
    
    for (char c = 'a'; c <= 'z'; c++) {
        current[pos] = c;
        generateSupersequences(words, wordCount, current, pos + 1, targetLen, result);
    }
}

int** solution(char** words, int wordCount, int* returnSize) {
    *returnSize = 0;
    if (wordCount == 0) return NULL;
    
    int minLen = 0;
    for (int i = 0; i < wordCount; i++) {
        int len = strlen(words[i]);
        if (len > minLen) minLen = len;
    }
    
    Result result = {NULL, 0, 10};
    result.arrays = malloc(result.capacity * sizeof(FreqArray));
    
    char* current = malloc(20 * sizeof(char));
    generateSupersequences(words, wordCount, current, 0, minLen, &result);
    free(current);
    
    if (result.count == 0) {
        free(result.arrays);
        return NULL;
    }
    
    int** finalResult = malloc(result.count * sizeof(int*));
    for (int i = 0; i < result.count; i++) {
        finalResult[i] = result.arrays[i].freq;
    }
    
    *returnSize = result.count;
    free(result.arrays);
    return finalResult;
}

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