Count Substrings That Can Be Rearranged to Contain a String I

Count Substrings That Can Be Rearranged to Contain a String I - Problem

You are given two strings word1 and word2. Your task is to find all substrings of word1 that can be rearranged to have word2 as a prefix.

A string x is called valid if we can rearrange the characters of x such that word2 appears at the beginning of the rearranged string.

For example: If word2 = "ab" and we have substring x = "bac", we can rearrange x to "abc", which has "ab" as a prefix, so x is valid.

Return the total number of valid substrings of word1.

Input & Output

example_1.py — Basic Case

$ Input: word1 = "abcabc", word2 = "ab"

› Output: 10

💡 Note: Valid substrings are: "ab" (positions 0-1), "abc" (0-2), "abca" (0-3), "abcab" (0-4), "abcabc" (0-5), "bca" (1-3), "bcab" (1-4), "bcabc" (1-5), "cab" (2-4), "cabc" (2-5). Each contains at least one 'a' and one 'b'.

example_2.py — Single Character

$ Input: word1 = "aaaa", word2 = "a"

› Output: 10

💡 Note: All substrings of "aaaa" contain at least one 'a', so all 10 possible substrings are valid: "a" appears 4 times, "aa" appears 3 times, "aaa" appears 2 times, "aaaa" appears 1 time. Total: 4+3+2+1 = 10.

example_3.py — No Valid Substrings

$ Input: word1 = "xyz", word2 = "ab"

› Output: 0

💡 Note: word1 contains no 'a' or 'b' characters, so no substring can be rearranged to have "ab" as a prefix.

Constraints

1 ≤ word2.length ≤ word1.length ≤ 10⁴
word1 and word2 consist only of lowercase English letters
word2 is not empty

Visualization

Tap to expand

Understanding the Visualization

Position Window

Place window at starting position and begin expanding

Count Letters

Count frequency of each letter as window expands

Check Requirements

Verify if we have enough of each required letter

Count Valid Extensions

Once requirements met, all longer substrings are also valid

Key Takeaway

🎯 Key Insight: We don't need to actually rearrange strings - just check if character frequencies are sufficient!

Asked in

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

The optimal approach uses a sliding window technique with character frequency counting. For each starting position, we expand the window until we have enough characters to form word2 as a prefix. Once satisfied, all further extensions are automatically valid, giving us O(n²) time complexity instead of the naive O(n³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(k)	Generate all substrings and check if each can contain word2 as prefix
Sliding Window (Optimal)	O(n²)	O(k)	Use sliding window with character frequency counting for efficient solution

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings of word1
For each substring, count character frequencies
Check if substring has enough characters to form word2 as prefix
Count all valid substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings of word1

Count Characters

For each substring, count frequency of each character

Validate

Check if substring has enough characters to form word2 as prefix

Code -

solution.c — C

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

int countSubstrings(char* word1, char* word2) {
    int word2Count[26] = {0};
    int len2 = strlen(word2);
    
    for (int i = 0; i < len2; i++) {
        word2Count[word2[i] - 'a']++;
    }
    
    int result = 0;
    int n = strlen(word1);
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            int substringCount[26] = {0};
            
            for (int k = i; k < j; k++) {
                substringCount[word1[k] - 'a']++;
            }
            
            int valid = 1;
            for (int k = 0; k < 26; k++) {
                if (substringCount[k] < word2Count[k]) {
                    valid = 0;
                    break;
                }
            }
            
            if (valid) result++;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings, each taking O(n) time to count characters

⚠ Quadratic Growth

Space Complexity

O(k)

Where k is the number of unique characters in word2

✓ Linear Space

23.8K Views

Medium Frequency

~25 min Avg. Time

892 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 (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler