Substring with Concatenation of All Words

Substring with Concatenation of All Words - Problem

You are given a string s and an array of strings words. All the strings of words are of the same length.

A concatenated string is a string that exactly contains all the strings of any permutation of words concatenated.

For example, if words = ["ab","cd","ef"], then "abcdef", "abefcd", "cdabef", "cdefab", "efabcd", and "efcdab" are all concatenated strings. "acdbef" is not a concatenated string because it is not the concatenation of any permutation of words.

Return an array of the starting indices of all the concatenated substrings in s. You can return the answer in any order.

Input & Output

Example 1 — Basic Concatenation

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

› Output: [0,9]

💡 Note: Position 0: "barfoo" = "bar" + "foo". Position 9: "foobar" = "foo" + "bar". Both are valid concatenations.

Example 2 — No Matches

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

› Output: []

💡 Note: No substring of length 16 contains exactly the words ["word","good","best","good"] in any order.

Example 3 — Multiple Matches

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

› Output: [0,3]

💡 Note: Position 0: "barfoo", Position 3: "foobar". Both contain exactly one "bar" and one "foo".

Constraints

1 ≤ s.length ≤ 10⁴
1 ≤ words.length ≤ 5000
1 ≤ words[i].length ≤ 30
s and words[i] consist of lowercase English letters

Visualization

Tap to expand

Asked in

A Amazon 45 G Google 38 F Facebook 32 M Microsoft 28

The key insight is to use frequency counting instead of generating permutations. Create a hash map of word frequencies, then slide a window and compare frequencies at each position. Best approach uses optimized sliding window with early termination. Time: O(n×m×k), Space: O(m×k)

Common Approaches

✓ Brute Force

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

For each position in the string, extract a substring of total length and check if it can be formed by concatenating all words in any order. This involves checking all possible permutations of the words array.

Optimized Sliding Window

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

Optimize the sliding window approach by breaking early when an invalid word is found and using more efficient frequency tracking. This avoids unnecessary computation when we know a window cannot match.

Sliding Window with Hash Map

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

Instead of generating permutations, use a hash map to count word frequencies and slide a window of the total concatenation length. At each position, check if the window contains exactly the required words.

Brute Force — Algorithm Steps

For each position i in string s
Extract substring of length (words.length * word_length)
Check if substring matches any permutation of words
If match found, add i to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of words

Check Each Position

At each position, extract substring and compare with permutations

Collect Results

Add matching positions to result array

Code -

solution.c — C

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

#define MAXN 5005
#define MAXWL 35
#define MAXSL 10005
#define MAXPERM 120  // max permutations for small word counts

int wordCount;
int wordLen;
char words[MAXN][MAXWL];
char tmp[MAXN][MAXWL];
char perms[MAXPERM][MAXWL * 30];
int permCount;

void swapStr(char a[], char b[]) {
    char t[MAXWL];
    strcpy(t, a);
    strcpy(a, b);
    strcpy(b, t);
}

int cmpStr(const void* a, const void* b) {
    return strcmp((const char*)a, (const char*)b);
}

int nextPermutation(char arr[][MAXWL], int n) {
    int i = n - 2;
    while (i >= 0 && strcmp(arr[i], arr[i + 1]) >= 0) i--;
    if (i < 0) return 0;
    int j = n - 1;
    while (strcmp(arr[j], arr[i]) <= 0) j--;
    swapStr(arr[i], arr[j]);
    int l = i + 1, r = n - 1;
    while (l < r) { swapStr(arr[l], arr[r]); l++; r--; }
    return 1;
}

void buildPermutations() {
    memcpy(tmp, words, sizeof(words));
    qsort(tmp, wordCount, MAXWL, cmpStr);
    permCount = 0;
    do {
        char perm[MAXWL * 30] = "";
        for (int i = 0; i < wordCount; i++) strcat(perm, tmp[i]);
        strcpy(perms[permCount++], perm);
    } while (nextPermutation(tmp, wordCount));
}

void parseWords(char* line) {
    wordCount = 0;
    int len = strlen(line);
    int wi = 0, inWord = 0;
    for (int i = 1; i < len - 1; i++) {
        char c = line[i];
        if (c == '"') {
            if (inWord) {
                words[wordCount][wi] = '\0';
                wordCount++;
                wi = 0;
                inWord = 0;
            } else {
                inWord = 1;
            }
        } else if (inWord) {
            words[wordCount][wi++] = c;
        }
    }
}

int main() {
    char s[MAXSL];
    char wordsLine[MAXSL];

    fgets(s, sizeof(s), stdin);
    int sl = strlen(s);
    if (s[sl - 1] == '\n') s[sl - 1] = '\0';

    fgets(wordsLine, sizeof(wordsLine), stdin);
    int wl = strlen(wordsLine);
    if (wordsLine[wl - 1] == '\n') wordsLine[wl - 1] = '\0';

    parseWords(wordsLine);

    if (wordCount == 0) { printf("[]\n"); return 0; }

    wordLen = strlen(words[0]);
    int totalLen = wordLen * wordCount;
    int sLen = strlen(s);

    buildPermutations();

    int result[MAXSL];
    int resultCount = 0;

    for (int i = 0; i <= sLen - totalLen; i++) {
        char substring[MAXWL * 30];
        strncpy(substring, s + i, totalLen);
        substring[totalLen] = '\0';
        for (int p = 0; p < permCount; p++) {
            if (strcmp(substring, perms[p]) == 0) {
                result[resultCount++] = i;
                break;
            }
        }
    }

    printf("[");
    for (int i = 0; i < resultCount; i++) {
        printf("%d", result[i]);
        if (i < resultCount - 1) printf(",");
    }
    printf("]\n");

    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m! × k)

For each of n positions, generate m! permutations of m words, each taking O(k) time to check

✓ Linear Growth

Space Complexity

O(m! × k)

Store all permutations of words, each permutation has m words of length k

✓ Linear Space

85.0K Views

Medium Frequency

~35 min Avg. Time

2.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler