Find Longest Self-Contained Substring - Practice Coding Problems

Find Longest Self-Contained Substring - Problem

Imagine you have a string and need to find the longest self-contained substring within it. A substring is considered self-contained if:

It's not the entire original string
Every character in this substring exists only within this substring and nowhere else in the original string

For example, in the string "abcdefabc", the substring "def" is self-contained because 'd', 'e', and 'f' don't appear anywhere else in the string.

Goal: Find the length of the longest such self-contained substring. If no self-contained substring exists, return -1.

Input & Output

example_1.py — Basic Case

$ Input: s = "abcdefabc"

› Output: 3

💡 Note: The substring "def" (positions 3-5) is self-contained because characters 'd', 'e', and 'f' appear only in this substring and nowhere else in the string. Length = 3.

example_2.py — No Self-Contained Substring

$ Input: s = "aabbcc"

› Output: -1

💡 Note: No self-contained substring exists. Every possible substring contains characters that also appear elsewhere in the string.

example_3.py — Multiple Valid Substrings

$ Input: s = "abcxyzabc"

› Output: 3

💡 Note: The substring "xyz" (positions 3-5) is self-contained with length 3. Characters 'x', 'y', 'z' don't appear anywhere else in the string.

Constraints

1 ≤ s.length ≤ 10⁴
s consists of lowercase English letters only
A self-contained substring cannot be the entire original string
Return -1 if no valid self-contained substring exists

Visualization

Tap to expand

Understanding the Visualization

City Census

Count where each 'resident' (character) lives in the entire 'city' (string)

Neighborhood Check

For each potential 'neighborhood' (substring), verify if it's truly exclusive

Find Largest

Identify the biggest exclusive neighborhood that meets our criteria

Key Takeaway

🎯 Key Insight: A substring is self-contained when its character frequencies exactly match the global frequencies for those characters - like finding a neighborhood where all residents are exclusive to that area!

Asked in

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

The optimal solution uses a sliding window approach with hash maps to achieve O(n²) time complexity. We first build a global character frequency map, then use nested loops to check all possible substrings efficiently. The key insight is that a substring is self-contained when its local character frequencies exactly match the global frequencies for those characters.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Maps	O(n²)	O(k)	Use sliding window technique with efficient character tracking for optimal performance
Two-Pass Hash Table Optimization	O(n³)	O(n)	First pass counts all character frequencies, second pass efficiently checks substrings
Brute Force (Check All Substrings)	O(n³)	O(n)	Generate all possible substrings and check if each is self-contained

Sliding Window with Hash Maps — Algorithm Steps

Build global character frequency map in O(n) time
Use sliding window approach to generate all substrings efficiently
Maintain running frequency count as window expands/contracts
Check self-containment by comparing running count with global frequencies
Track maximum length of valid self-contained substrings found

Visualization

Tap to expand

Step-by-Step Walkthrough

Global Frequency Map

Build complete character frequency map once

Sliding Window

Expand window incrementally, updating local frequencies

Efficient Validation

Compare frequencies without rebuilding maps

Code -

solution.c — C

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

#define MAX_CHARS 256

int solution(char* s) {
    int n = strlen(s);
    if (n <= 1) return -1;
    
    // Build global character frequency map
    int globalFreq[MAX_CHARS] = {0};
    for (int i = 0; i < n; i++) {
        globalFreq[(unsigned char)s[i]]++;
    }
    
    int maxLength = -1;
    
    // Sliding window approach
    for (int start = 0; start < n; start++) {
        int localFreq[MAX_CHARS] = {0};
        
        for (int end = start; end < n; end++) {
            // Add current character to window
            unsigned char c = (unsigned char)s[end];
            localFreq[c]++;
            
            int windowLen = end - start + 1;
            
            // Skip if this is the entire string
            if (windowLen == n) continue;
            
            // Check if current window is self-contained
            int isSelfContained = 1;
            for (int i = start; i <= end && isSelfContained; i++) {
                unsigned char ch = (unsigned char)s[i];
                if (globalFreq[ch] != localFreq[ch]) {
                    isSelfContained = 0;
                }
            }
            
            if (isSelfContained && windowLen > maxLength) {
                maxLength = windowLen;
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    printf("%d\n", solution(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) for global frequency + O(n²) for sliding window with O(1) frequency updates

⚠ Quadratic Growth

Space Complexity

O(k)

O(k) space where k is the number of unique characters

✓ Linear Space

41.5K Views

Medium-High Frequency

~25 min Avg. Time

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

Sliding Window with Hash Maps — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler