Substring with Concatenation of All Words

Substring with Concatenation of All Words - Problem

You're given a string s and an array of strings words, where all strings in words have the same length. Your task is to find all starting indices in s where a concatenated substring begins.

A concatenated substring is formed by joining all strings from words in any order, using each word exactly once. For example, if words = ["ab", "cd", "ef"], then valid concatenated strings include:

"abcdef", "abefcd", "cdabef"
"cdefab", "efabcd", "efcdab"

However, "acdbef" would not be valid because it doesn't represent any permutation of the original words.

Goal: Return an array of all starting indices where these concatenated substrings appear in s.

Input & Output

example_1.py — Basic case

$ Input: s = "barfoothe", words = ["foo","bar"]

› Output: [0, 3]

💡 Note: At index 0: "barfoo" can be split into "bar" + "foo". At index 3: "foobar" can be split into "foo" + "bar". Both use all words exactly once.

example_2.py — No valid concatenation

$ Input: s = "wordgoodgoodgoodword", words = ["word","good","best","good"]

› Output: []

💡 Note: No substring contains all required words. We need "word", "good", "best", and "good" (note: "good" appears twice in words array), but "best" never appears in string s.

example_3.py — Multiple valid positions

$ Input: s = "barfoobar", words = ["foo","bar"]

› Output: [0, 3]

💡 Note: At index 0: "barfoo" = "bar" + "foo". At index 3: "foobar" = "foo" + "bar". Index 6 would be "bar" alone, which doesn't use all words.

Visualization

Tap to expand

Understanding the Visualization

Set up the puzzle

We have a long string (puzzle strip) and word pieces that must fit exactly

Try different starting positions

For each possible alignment, slide a window across the strip

Check piece fit

At each position, verify that the pieces match our target collection exactly

Record solutions

When pieces align perfectly, mark that position as a solution

Key Takeaway

🎯 Key Insight: By using sliding windows with different starting offsets and maintaining word frequency counts, we can efficiently find all valid concatenation positions without redundant work.

Time & Space Complexity

Time Complexity

⏱️

O(n * w)

We process each character at most a constant number of times across all sliding windows

✓ Linear Growth

Space Complexity

O(m * w)

Space for hash maps storing word frequencies and current window state

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ words.length ≤ 5000
1 ≤ words[i].length ≤ 30
All strings of words are the same length
s and words[i] consist of lowercase English letters only

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28 Apple 22

The optimal approach uses a sliding window technique with hash maps. For each possible starting offset (0 to word_length-1), we maintain a sliding window and track word frequencies dynamically. This achieves O(n × w) time complexity, where n is string length and w is word length, making it much more efficient than the brute force O(n × m × w) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Position)	O(n * m * w)	O(m * w)	Check every possible starting position and verify if it forms a valid concatenation
Sliding Window with Hash Map (Optimal)	O(n * w)	O(m * w)	Use sliding window technique with hash maps to efficiently find all concatenations

Brute Force (Check Every Position) — Algorithm Steps

Iterate through each possible starting position in string s
Extract substring of length (word_length * num_words)
Split the substring into chunks of word_length
Check if these chunks form exactly the words we need
Use frequency counting to handle duplicate words

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Extract substring of required length

Split into words

Break substring into word-length chunks

Count frequencies

Compare word counts with target

Move to next position

Repeat for all positions

Code -

solution.c — C

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

typedef struct {
    char* word;
    int count;
} WordCount;

int* findSubstring(char* s, char** words, int wordsSize, int* returnSize) {
    *returnSize = 0;
    if (!s || !words || wordsSize == 0) return NULL;
    
    int sLen = strlen(s);
    int wordLen = strlen(words[0]);
    int totalLen = wordLen * wordsSize;
    
    int* result = (int*)malloc(sLen * sizeof(int));
    
    // Check each possible starting position
    for (int i = 0; i <= sLen - totalLen; i++) {
        // Create frequency arrays for this position
        WordCount wordCount[1000]; // Assume max 1000 unique words
        WordCount seen[1000];
        int wordCountSize = 0, seenSize = 0;
        
        // Initialize word count
        for (int w = 0; w < wordsSize; w++) {
            int found = 0;
            for (int c = 0; c < wordCountSize; c++) {
                if (strcmp(wordCount[c].word, words[w]) == 0) {
                    wordCount[c].count++;
                    found = 1;
                    break;
                }
            }
            if (!found) {
                wordCount[wordCountSize].word = words[w];
                wordCount[wordCountSize].count = 1;
                wordCountSize++;
            }
        }
        
        // Check substring
        int valid = 1;
        for (int j = 0; j < totalLen && valid; j += wordLen) {
            char word[wordLen + 1];
            strncpy(word, s + i + j, wordLen);
            word[wordLen] = '\0';
            
            // Find in seen array
            int found = 0;
            for (int c = 0; c < seenSize; c++) {
                if (strcmp(seen[c].word, word) == 0) {
                    seen[c].count++;
                    found = 1;
                    break;
                }
            }
            if (!found) {
                seen[seenSize].word = malloc(wordLen + 1);
                strcpy(seen[seenSize].word, word);
                seen[seenSize].count = 1;
                seenSize++;
            }
            
            // Check if word exists and count doesn't exceed
            found = 0;
            for (int c = 0; c < wordCountSize; c++) {
                if (strcmp(wordCount[c].word, word) == 0) {
                    found = 1;
                    int seenCount = 0;
                    for (int s = 0; s < seenSize; s++) {
                        if (strcmp(seen[s].word, word) == 0) {
                            seenCount = seen[s].count;
                            break;
                        }
                    }
                    if (seenCount > wordCount[c].count) {
                        valid = 0;
                    }
                    break;
                }
            }
            if (!found) valid = 0;
        }
        
        // Final validation
        if (valid) {
            int match = 1;
            for (int c = 0; c < wordCountSize && match; c++) {
                int seenCount = 0;
                for (int s = 0; s < seenSize; s++) {
                    if (strcmp(seen[s].word, wordCount[c].word) == 0) {
                        seenCount = seen[s].count;
                        break;
                    }
                }
                if (seenCount != wordCount[c].count) match = 0;
            }
            if (match) {
                result[(*returnSize)++] = i;
            }
        }
        
        // Cleanup seen array
        for (int s = 0; s < seenSize; s++) {
            free(seen[s].word);
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m * w)

n positions to check, m words to verify, w average word length operations

✓ Linear Growth

Space Complexity

O(m * w)

Space for storing word frequency maps and temporary substrings

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ words.length ≤ 5000
1 ≤ words[i].length ≤ 30
All strings of words are the same length
s and words[i] consist of lowercase English letters only

58.6K Views

High Frequency

~25 min Avg. Time

1.8K 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 (Check Every Position) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler