Find Longest Special Substring That Occurs Thrice I

Find Longest Special Substring That Occurs Thrice I - Problem

You are given a string s consisting of lowercase English letters. Your task is to find the longest special substring that appears at least three times in the string.

A special substring is one that contains only a single type of character. For example:

"aaa", "bb", and "c" are special substrings
"abc", "aab", and "xy" are not special substrings

Goal: Return the length of the longest special substring that occurs at least 3 times, or -1 if no such substring exists.

Note: A substring is a contiguous sequence of characters within the string.

Input & Output

example_1.py — Basic Case

$ Input: s = "aaaa"

› Output: 2

💡 Note: The special substrings are "a" (appears 4 times), "aa" (appears 3 times), "aaa" (appears 2 times), and "aaaa" (appears 1 time). The longest special substring that occurs at least thrice is "aa" with length 2.

example_2.py — Mixed Characters

$ Input: s = "abcdef"

› Output: -1

💡 Note: All characters appear only once. Each single character special substring ("a", "b", "c", "d", "e", "f") appears exactly 1 time, which is less than 3. No special substring occurs at least thrice.

example_3.py — Multiple Groups

$ Input: s = "abcaba"

› Output: 1

💡 Note: The character 'a' appears 3 times and 'b' appears 2 times. The special substring "a" occurs 3 times (at positions 0, 3, 5), which satisfies the requirement. The longest special substring that occurs at least thrice is "a" with length 1.

Visualization

Tap to expand

Understanding the Visualization

Scan DNA Strand

Examine the DNA sequence character by character

Group Identical Nucleotides

Identify consecutive sequences of the same nucleotide (A, T, G, C)

Count Pattern Occurrences

For each group, calculate how many patterns of each length it contributes

Find Most Common Pattern

Identify the longest pattern that appears at least 3 times across the strand

Key Takeaway

🎯 Key Insight: Instead of checking every possible substring (O(n³)), group consecutive identical characters and use mathematical formulas to count special substrings efficiently in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to group characters, constant work per group

✓ Linear Growth

Space Complexity

O(n)

Hash map to store counts for each (character, length) combination

⚡ Linearithmic Space

Constraints

3 ≤ s.length ≤ 50
s consists of only lowercase English letters
A special substring must occur at least 3 times
Return -1 if no valid special substring exists

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24

The optimal solution uses character grouping to efficiently count special substrings. Instead of generating all O(n²) substrings, we identify consecutive character groups and use mathematical formulas to count substring occurrences in O(n) time. For a group of k consecutive identical characters, we can form (k-i+1) special substrings of length i. This approach scales excellently and avoids redundant work.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(n²)	Generate all possible substrings, check if special, count occurrences
Optimized Hash Table (Optimal)	O(n)	O(n)	Group consecutive characters and count special substrings efficiently

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings using nested loops
For each substring, check if it's special (all characters are the same)
Count occurrences of each special substring in the original string
Track the maximum length among substrings with count >= 3
Return the maximum length or -1 if none found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible contiguous substrings

Check Special Property

Verify each substring contains only one character type

Count Occurrences

Count how many times each special substring appears

Find Maximum

Return length of longest substring with count ≥ 3

Code -

solution.c — C

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

#define MAX_LEN 1000

int maximumLength(char* s) {
    int n = strlen(s);
    int maxLength = -1;
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            int len = j - i;
            
            // Check if substring is special
            int isSpecial = 1;
            for (int k = i + 1; k < j; k++) {
                if (s[k] != s[i]) {
                    isSpecial = 0;
                    break;
                }
            }
            
            if (isSpecial) {
                // Count occurrences
                int count = 0;
                for (int start = 0; start <= n - len; start++) {
                    int match = 1;
                    for (int k = 0; k < len; k++) {
                        if (s[start + k] != s[i + k]) {
                            match = 0;
                            break;
                        }
                    }
                    if (match) count++;
                }
                
                if (count >= 3 && len > maxLength) {
                    maxLength = len;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char s[MAX_LEN];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0; // Remove newline
    printf("%d\n", maximumLength(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all substrings, O(n) to count each substring's occurrences

⚠ Quadratic Growth

Space Complexity

O(n²)

Storage for all special substrings and their counts

⚠ Quadratic Space

Constraints

3 ≤ s.length ≤ 50
s consists of only lowercase English letters
A special substring must occur at least 3 times
Return -1 if no valid special substring exists

32.4K Views

Medium-High Frequency

~18 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler