Number of Strings Which Can Be Rearranged to Contain Substring

Number of Strings Which Can Be Rearranged to Contain Substring - Problem

Problem: Given an integer n, find how many strings of length n using only lowercase English letters can be rearranged to contain the substring "leet".

What makes a string "good"?
A string is considered good if we can rearrange its characters to form a new string that contains "leet" as a contiguous substring.

Examples:
• "lteer" → can be rearranged to "leetr" ✅
• "letl" → cannot form "leet" (missing one 'e') ❌
• "aleteb" → can be rearranged to "leetab" ✅

Key Insight: A string can be rearranged to contain "leet" if and only if it has at least 2 'l's, 2 'e's, and 1 't'. The remaining positions can be filled with any lowercase letters.

Return the answer modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: n = 4

› Output: 12

💡 Note: For n=4, we need at least 2 l's, 2 e's, and 1 t (total 5 letters). Since we only have 4 positions, we need exactly 2 l's, 2 e's, 1 t, but that requires 5 letters. However, we can have strings like "llet" (2 l's, 1 e, 1 t) that can't form "leet". The actual count requires careful combinatorial calculation.

example_2.py — Minimum Length

$ Input: n = 7

› Output: 3196

💡 Note: With 7 positions, we have more flexibility. We need ≥2 l's, ≥2 e's, ≥1 t, leaving 2 positions for any letters. Using inclusion-exclusion principle, we subtract invalid combinations from 26^7.

example_3.py — Edge Case

$ Input: n = 3

› Output: 0

💡 Note: With only 3 positions, it's impossible to have at least 2 l's, 2 e's, and 1 t (which requires minimum 5 letters). Therefore, no valid strings exist.

Constraints

1 ≤ n ≤ 10⁵
Answer should be returned modulo 10⁹ + 7
Only lowercase English letters are allowed in strings

Visualization

Tap to expand

Understanding the Visualization

Count Required Letters

We need ≥2 l's, ≥2 e's, ≥1 t to form 'leet'

Calculate Total Possibilities

Without constraints: 26^n possible strings

Subtract Invalid Cases

Use inclusion-exclusion to remove strings missing required letters

Get Final Count

Valid strings = Total - Invalid using set theory

Key Takeaway

🎯 Key Insight: Use inclusion-exclusion principle to count mathematically rather than generate all strings - this transforms an exponential problem into a constant-time calculation!

Asked in

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

The optimal solution uses the inclusion-exclusion principle from combinatorics. Instead of generating strings, we calculate mathematically: total strings (26ⁿ) minus strings that don't meet requirements. A string is good if it has ≥2 l's, ≥2 e's, and ≥1 t. We define sets A, B, C for strings missing each constraint and apply |A∪B∪C| = |A|+|B|+|C|-|A∩B|-|A∩C|-|B∩C|+|A∩B∩C| to count invalid strings, then subtract from total.

Common Approaches

Approach	Time	Space	Notes
✓ Inclusion-Exclusion Principle (Optimal)	O(1)	O(1)	Use combinatorics and inclusion-exclusion to count valid strings mathematically
Brute Force (Generate All Strings)	O(26^n)	O(26^n)	Generate all possible strings and check each one for sufficient letters

Inclusion-Exclusion Principle (Optimal) — Algorithm Steps

Calculate total possible strings: 26^n
Subtract strings missing at least one constraint using inclusion-exclusion
Use sets: A = missing ≥2 l's, B = missing ≥2 e's, C = missing ≥1 t
Apply |A ∪ B ∪ C| = |A| + |B| + |C| - |A ∩ B| - |A ∩ C| - |B ∩ C| + |A ∩ B ∩ C|
Calculate each term using combinatorics and modular arithmetic

Visualization

Tap to expand

Step-by-Step Walkthrough

Total Strings

Start with all possible strings: 26^n

Define Bad Sets

A = missing ≥2 l's, B = missing ≥2 e's, C = missing ≥1 t

Apply Formula

Use inclusion-exclusion: |A∪B∪C| = |A|+|B|+|C|-|A∩B|-|A∩C|-|B∩C|+|A∩B∩C|

Calculate Result

Good strings = Total - Bad strings

Code -

solution.c — C

#include <stdio.h>

#define MOD 1000000007

long long power(long long base, long long exp, long long mod) {
    long long result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp & 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp >>= 1;
    }
    return result;
}

int stringCount(int n) {
    if (n < 4) return 0;
    
    long long total = power(26, n, MOD);
    
    // A: < 2 l's, B: < 2 e's, C: < 1 t
    long long A = (power(25, n, MOD) + ((long long)n * power(25, n-1, MOD)) % MOD) % MOD;
    long long B = (power(25, n, MOD) + ((long long)n * power(25, n-1, MOD)) % MOD) % MOD;
    long long C = power(25, n, MOD);
    
    long long AB = (power(24, n, MOD) + ((long long)n * power(24, n-1, MOD)) % MOD + ((long long)n * power(24, n-1, MOD)) % MOD + ((long long)n * (n-1) * power(24, n-2, MOD)) % MOD) % MOD;
    long long AC = (power(24, n, MOD) + ((long long)n * power(24, n-1, MOD)) % MOD) % MOD;
    long long BC = (power(24, n, MOD) + ((long long)n * power(24, n-1, MOD)) % MOD) % MOD;
    
    long long ABC = (power(23, n, MOD) + ((long long)n * power(23, n-1, MOD)) % MOD + ((long long)n * power(23, n-1, MOD)) % MOD + ((long long)n * (n-1) * power(23, n-2, MOD)) % MOD) % MOD;
    
    long long bad = (A + B + C - AB - AC - BC + ABC) % MOD;
    long long result = (total - bad + MOD) % MOD;
    
    return (int) result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", stringCount(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Only requires constant number of power and arithmetic operations

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for calculations

✓ Linear Space

28.5K 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

Inclusion-Exclusion Principle (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler