Find Longest Special Substring That Occurs Thrice II

Find Longest Special Substring That Occurs Thrice II - Problem

Find the Longest Repeating Character Substring

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

A special substring is one that contains only a single unique character. For example:
• "aaa" is special (only 'a')
• "bb" is special (only 'b')
• "abc" is NOT special (multiple characters)

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

Example: In "aaabbbccc", the substring "aa" appears 2 times, but "a" appears 3 times, so the answer is 1.

Input & Output

example_1.py — Basic Case

$ Input: s = "aaaa"

› Output: 2

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

example_2.py — Mixed Characters

$ Input: s = "abcdef"

› Output: -1

💡 Note: No character repeats consecutively, so the only special substrings are single characters, each appearing exactly once. Since we need at least 3 occurrences, the answer is -1.

example_3.py — Multiple Groups

$ Input: s = "abcaba"

› Output: 1

💡 Note: Character 'a' appears 3 times (positions 0, 3, 5) and character 'b' appears 2 times. Only 'a' appears at least 3 times, so the answer is 1.

Constraints

3 ≤ s.length ≤ 5 × 10⁴
s consists of only lowercase English letters
Need at least 3 occurrences of the special substring

Visualization

Tap to expand

Understanding the Visualization

Scan & Group

Identify consecutive character sequences: 'aaabaa' → groups: [3,3] for 'a', [1] for 'b'

Track Top 3

Keep only the 3 longest sequences for each character (pad with zeros if needed)

Calculate Maximum

For each character, find max length appearing ≥3 times using three formulas

Return Best

Take the maximum result across all character types

Key Takeaway

🎯 Key Insight: We only need the top 3 consecutive lengths per character because there are exactly 3 ways to form 3 occurrences, and shorter substrings can always be derived from longer ones mathematically!

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 31

The optimal approach groups consecutive identical characters and uses the mathematical insight that we only need to track the top 3 longest sequences for each character. From these, we can calculate the maximum length that appears at least 3 times using three cases: all from one group, two from one + one from another, or one from each of three groups. This achieves O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Character Grouping (Optimal)	O(n)	O(1)	Group consecutive characters and track top 3 lengths for each character type
Binary Search on Answer	O(n log n)	O(n)	Binary search on the possible length, check if any length k can appear ≥3 times
Brute Force (Generate All Substrings)	O(n³)	O(n²)	Generate all possible special substrings and count their occurrences

Optimized Character Grouping (Optimal) — Algorithm Steps

Scan string to find all consecutive character groups and their lengths
For each character, maintain the 3 longest consecutive lengths
For each character, calculate maximum possible length that occurs ≥3 times
Use the insight that from a length-k sequence, we get k sequences of length 1, (k-1) of length 2, etc.
Return the maximum length across all characters

Visualization

Tap to expand

Step-by-Step Walkthrough

Group Consecutive

Identify all consecutive character sequences and their lengths

Track Top 3

For each character, keep only the 3 longest consecutive sequences

Calculate Possibilities

Use math to determine max length that appears ≥3 times

Return Maximum

Find the maximum across all character types

Code -

solution.c — C

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

#define MAX_LEN 50001

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a);  // Descending order
}

int min(int a, int b) {
    return a < b ? a : b;
}

int max(int a, int b) {
    return a > b ? a : b;
}

int maximumLength(char* s) {
    int n = strlen(s);
    int groups[26][1000];  // groups[char-'a'][i] = length
    int groupCounts[26] = {0};
    
    // Group consecutive characters
    int i = 0;
    while (i < n) {
        char ch = s[i];
        int length = 1;
        
        while (i + length < n && s[i + length] == ch) {
            length++;
        }
        
        int idx = ch - 'a';
        groups[idx][groupCounts[idx]++] = length;
        i += length;
    }
    
    int maxLength = -1;
    
    // For each character, find max length that appears >= 3 times
    for (int c = 0; c < 26; c++) {
        if (groupCounts[c] == 0) continue;
        
        // Sort in descending order
        qsort(groups[c], groupCounts[c], sizeof(int), compare);
        
        int lengths[3] = {0, 0, 0};
        for (int j = 0; j < min(3, groupCounts[c]); j++) {
            lengths[j] = groups[c][j];
        }
        
        // Check possible answers
        if (lengths[0] >= 3) {
            maxLength = max(maxLength, lengths[0] - 2);
        }
        
        if (lengths[0] >= 2 && lengths[1] >= 1) {
            maxLength = max(maxLength, min(lengths[0] - 1, lengths[1]));
        }
        
        if (lengths[0] >= 1 && lengths[1] >= 1 && lengths[2] >= 1) {
            maxLength = max(maxLength, min(min(lengths[0], lengths[1]), lengths[2]));
        }
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to group characters, then O(26) to process each character type

✓ Linear Growth

Space Complexity

O(1)

Only store at most 26 characters × 3 top lengths = constant space

✓ Linear Space

38.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

Optimized Character Grouping (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler