Find Longest Special Substring That Occurs Thrice I - Problem

You are given a string s that consists of lowercase English letters.

A string is called special if it is made up of only a single character. For example, the string "abc" is not special, whereas the strings "ddd", "zz", and "f" are special.

Return the length of the longest special substring of s which occurs at least thrice, or -1 if no special substring occurs at least thrice.

A substring is a contiguous non-empty sequence of characters within a string.

Input & Output

Example 1 — Basic Special Substrings

$ Input: s = "aaaa"

› Output: 2

💡 Note: Special substrings: "a" occurs 4 times, "aa" occurs 3 times, "aaa" occurs 2 times (less than 3). The longest special substring that occurs at least thrice is "aa" with length 2.

Example 2 — Mixed Characters

$ Input: s = "abcdef"

› Output: -1

💡 Note: Each character appears only once, so no special substring can occur 3 or more times. Return -1.

Example 3 — Multiple Character Runs

$ Input: s = "abcaba"

› Output: 1

💡 Note: Only "a" and "b" can form special substrings. Character "a" appears 3 times total, character "b" appears 2 times. Only "a" occurs at least 3 times, so return length 1.

Constraints

3 ≤ s.length ≤ 50
s consists of only lowercase English letters.

Visualization

Tap to expand

Asked in

G Google 12 f Facebook 8 a Amazon 6

The key insight is to analyze consecutive runs of each character rather than generating all substrings. For each character, we can mathematically calculate how many special substrings of each length can be formed from its runs. Best approach uses character run analysis with Time: O(n), Space: O(n).

Common Approaches

✓ Brute Force - Check All Substrings

⏱️ Time: O(n³) Space: O(1)

For each possible starting position and length, extract the substring, check if it's special (all same character), and count how many times it appears in the string.

Frequency Count with HashMap

⏱️ Time: O(n²) Space: O(n²)

Generate all special substrings by finding consecutive runs of the same character, then use a hash map to count occurrences of each substring length per character.

Optimized Character Run Analysis

⏱️ Time: O(n) Space: O(n)

Instead of generating all substrings, analyze consecutive runs of each character and mathematically determine the maximum length that can appear at least 3 times.

Brute Force - Check All Substrings — Algorithm Steps

Generate all possible substrings
Check if each substring is special (single character)
Count occurrences of each special substring
Return length of longest that occurs ≥3 times

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings of the string

Check Special

Verify if substring has only one unique character

Count Occurrences

Count how many times each special substring appears

Code -

solution.c — C

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

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

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: start position × length × counting occurrences

✓ Linear Growth

Space Complexity

O(1)

Only using variables for tracking, no extra data structures

⚡ Linearithmic Space

8.4K Views

Medium Frequency

~15 min Avg. Time

156 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

Find Longest Special Substring That Occurs Thrice I - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler