String Matching in an Array - Practice Coding Problems

String Matching in an Array - Problem

String Matching in an Array is a fundamental string manipulation problem that tests your ability to identify substring relationships efficiently.

You are given an array of strings called words. Your task is to find all strings that appear as substrings within other strings in the same array. A substring is a contiguous sequence of characters within a string.

For example, if you have ["mass", "as", "hero", "superhero"], both "as" (found in "mass") and "hero" (found in "superhero") should be returned.

The order of the result doesn't matter - you can return the matching strings in any sequence you prefer.

Input & Output

example_1.py — Basic Case

$ Input: ["mass","as","hero","superhero"]

› Output: ["as","hero"]

💡 Note: "as" is a substring of "mass", and "hero" is a substring of "superhero"

example_2.py — Multiple Matches

$ Input: ["leetcode","et","code"]

› Output: ["et","code"]

💡 Note: Both "et" and "code" are substrings of "leetcode"

example_3.py — No Matches

$ Input: ["blue","green","bu"]

› Output: []

💡 Note: None of the strings is a substring of another string in the array

Visualization

Tap to expand

Understanding the Visualization

Gather Evidence

Collect all the word clues in your array

Sort by Size

Arrange words from shortest to longest - smaller clues are more likely to be hidden

Search for Hidden Words

For each small word, check if it's completely contained in any larger word

Record Findings

Keep track of all the words that are found as substrings

Key Takeaway

🎯 Key Insight: By sorting strings by length first, we can optimize our search by only looking for shorter strings within longer ones, just like a detective focuses on the most promising leads first!

Time & Space Complexity

Time Complexity

⏱️

O(n log n + n² × m)

Sorting takes O(n log n), then we have nested comparisons O(n²) with substring search O(m), but in practice much faster due to fewer comparisons

⚠ Quadratic Growth

Space Complexity

O(k)

Space for result array where k is number of strings that are substrings

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 30
words[i] contains only lowercase English letters
All strings in words are unique

Asked in

a Amazon 35 ⊞ Microsoft 28 G Google 22 f Meta 15

The optimal approach involves sorting strings by length and comparing each string only with longer ones, reducing unnecessary comparisons. This gives us O(n² × m) time complexity in the worst case, but performs much better in practice due to early termination and fewer comparisons.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n² × m)	O(k)	Compare every string with every other string using nested loops
Optimized Comparison (Single Pass)	O(n log n + n² × m)	O(k)	Sort strings by length and compare each with longer strings only

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each string in the array
For each string, compare it with every other string
Use built-in substring search to check if current string exists in the other string
If found and strings are different, add to result
Return all found substring matches

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with array of strings and empty result

Outer Loop

Pick first string to check if it's a substring

Inner Loop

Compare with each other string in the array

Substring Check

Use built-in function to check if current string is contained in other

Add to Result

If found, add to result and break to next outer iteration

Code -

solution.c — C

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

char** stringMatching(char** words, int wordsSize, int* returnSize) {
    char** result = (char**)malloc(wordsSize * sizeof(char*));
    *returnSize = 0;
    
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; j < wordsSize; j++) {
            if (i != j && strstr(words[j], words[i]) != NULL) {
                result[*returnSize] = (char*)malloc((strlen(words[i]) + 1) * sizeof(char));
                strcpy(result[*returnSize], words[i]);
                (*returnSize)++;
                break;
            }
        }
    }
    
    return result;
}

int main() {
    char* words[] = {"mass", "as", "hero", "superhero"};
    int returnSize;
    char** result = stringMatching(words, 4, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² × m)

We have nested loops (n²) and for each pair we do substring search which takes O(m) time where m is the average string length

⚠ Quadratic Growth

Space Complexity

O(k)

Only space needed is for the result array where k is the number of strings that are substrings

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 30
words[i] contains only lowercase English letters
All strings in words are unique

28.6K Views

Medium Frequency

~12 min Avg. Time

956 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler