Length of the Longest Valid Substring - Practice Coding Problems

Length of the Longest Valid Substring - Problem

Find the longest valid substring in a given string where none of its substrings appear in a forbidden list.

You are given a string word and an array of strings forbidden. A substring is considered valid if none of its contiguous parts match any string in the forbidden array.

Example: If word = "cbaaaabc" and forbidden = ["aaa", "cb"], then the substring "aaab" is invalid because it contains "aaa", but "aa" would be valid.

Goal: Return the length of the longest valid substring possible.

Input & Output

example_1.py — Basic Case

$ Input: word = "cbaaaabc", forbidden = ["aaa", "cb"]

› Output: 4

💡 Note: The longest valid substring is "aaab" with length 4. It doesn't contain "aaa" or "cb" as substrings.

example_2.py — No Forbidden Match

$ Input: word = "leetcode", forbidden = ["de", "le", "e"]

› Output: 4

💡 Note: The longest valid substring is "tcod" with length 4, as it doesn't contain any forbidden substrings.

example_3.py — Edge Case

$ Input: word = "a", forbidden = ["b"]

› Output: 1

💡 Note: Since "a" doesn't contain the forbidden string "b", the entire string is valid with length 1.

Constraints

1 ≤ word.length ≤ 10⁴
word consists only of lowercase English letters
1 ≤ forbidden.length ≤ 10⁴
1 ≤ forbidden[i].length ≤ 10
forbidden[i] consists only of lowercase English letters
All strings in forbidden are unique

Visualization

Tap to expand

Understanding the Visualization

Setup Scanner

Load forbidden phrases into memory for quick lookup

Scan Forward

Move through document expanding safe zone

Hit Forbidden

When sensitive content found, restart after the forbidden phrase begins

Track Maximum

Remember the longest safe section discovered

Key Takeaway

🎯 Key Insight: When we find a forbidden substring, we don't need to check overlapping substrings - we can jump directly past the start of the forbidden content!

Asked in

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

The optimal solution uses a sliding window technique with a hash set to store forbidden strings. We expand the window and when a forbidden substring is found, we strategically move the left boundary to avoid redundant checks. This achieves better performance than brute force while maintaining correctness.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³ × m × k)	O(m × k)	Check every possible substring to see if it's valid
Sliding Window with Hash Set (Optimal)	O(n × m × k)	O(m × k)	Use sliding window technique with early termination when forbidden substring found

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings of the word
For each substring, check if it contains any forbidden string
Track the maximum length of valid substrings found
Return the maximum length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings from the word

Validate Each

Check if substring contains any forbidden string

Track Maximum

Keep track of longest valid substring found

Code -

solution.c — C

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

int longestValidSubstring(char* word, char** forbidden, int forbiddenSize) {
    int maxLen = 0;
    int n = strlen(word);
    
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            int isValid = 1;
            
            // Check all substrings of current substring
            for (int start = i; start <= j && isValid; start++) {
                for (int end = start; end <= j; end++) {
                    int subLen = end - start + 1;
                    char temp[subLen + 1];
                    strncpy(temp, word + start, subLen);
                    temp[subLen] = '\0';
                    
                    for (int k = 0; k < forbiddenSize; k++) {
                        if (strcmp(temp, forbidden[k]) == 0) {
                            isValid = 0;
                            break;
                        }
                    }
                    if (!isValid) break;
                }
            }
            
            if (isValid) {
                int len = j - i + 1;
                if (len > maxLen) maxLen = len;
            }
        }
    }
    
    return maxLen;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³ × m × k)

n² substrings, each taking O(n×m×k) to validate against m forbidden strings of average length k

⚠ Quadratic Growth

Space Complexity

O(m × k)

Space for storing forbidden strings in a set

✓ Linear Space

38.5K Views

Medium-High Frequency

~25 min Avg. Time

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