Find the Longest Semi-Repetitive Substring

Find the Longest Semi-Repetitive Substring - Problem

You are given a digit string s consisting of digits from 0 to 9. Your task is to find the longest semi-repetitive substring within this string.

A string is considered semi-repetitive if it contains at most one adjacent pair of the same digit. Think of it as allowing only one "double" digit occurrence in the entire substring.

Examples of semi-repetitive strings:

"0010" - has one adjacent pair (00)
"002020" - has one adjacent pair (00)
"0123" - has no adjacent pairs
"2002" - has one adjacent pair (00)
"54944" - has one adjacent pair (44)

Examples of NON semi-repetitive strings:

"00101022" - has two adjacent pairs: (00) and (22)
"1101234883" - has two adjacent pairs: (11) and (88)

Return the length of the longest semi-repetitive substring of s.

Input & Output

example_1.py — Basic Case

$ Input: s = "52233"

› Output: 4

💡 Note: The longest semi-repetitive substring is "5223" with length 4. It contains exactly one adjacent duplicate pair (22).

example_2.py — No Duplicates

$ Input: s = "5494"

› Output: 4

💡 Note: The entire string "5494" is semi-repetitive as it has no adjacent duplicate pairs. The length is 4.

example_3.py — Single Character

$ Input: s = "1"

› Output: 1

💡 Note: A single character string is always semi-repetitive. The length is 1.

Constraints

1 ≤ s.length ≤ 1000
s consists only of digits from '0' to '9'
The string is guaranteed to be non-empty

Visualization

Tap to expand

Understanding the Visualization

Start Small

Begin with a minimal window of size 1

Expand Greedily

Keep expanding the window as long as you have ≤ 1 duplicate pair

Contract When Needed

When you exceed 1 duplicate pair, shrink from the left

Track Maximum

Remember the largest valid window size you've seen

Key Takeaway

🎯 Key Insight: Use sliding window to maintain a substring with at most one adjacent duplicate pair, expanding greedily and contracting only when necessary.

Asked in

G Google 15 a Amazon 8 f Meta 6 ⊞ Microsoft 4

The optimal solution uses a sliding window approach with two pointers. We maintain a window that contains at most one adjacent duplicate pair, expanding the right pointer to grow the window and contracting from the left when we exceed the limit. This achieves O(n) time complexity and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to efficiently find the longest semi-repetitive substring
Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring and find the longest semi-repetitive one

Sliding Window (Optimal) — Algorithm Steps

Initialize left and right pointers, and counter for adjacent duplicate pairs
Expand right pointer and count adjacent duplicates as we add characters
When duplicate pairs exceed 1, shrink window from left until we have ≤ 1 pair
Track the maximum window size throughout the process

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Start with left=0, right=1, duplicatePairs=0

Expand Right

Move right pointer and count duplicate pairs

Contract if Needed

If duplicatePairs > 1, move left pointer until duplicatePairs ≤ 1

Track Maximum

Update maximum length with current window size

Code -

solution.c — C

int longestSemiRepetitiveSubstring(char* s) {
    int n = strlen(s);
    if (n <= 1) return n;
    
    int left = 0;
    int maxLength = 1;
    int duplicatePairs = 0;
    
    for (int right = 1; right < n; right++) {
        // Check if current character forms duplicate pair
        if (s[right] == s[right - 1]) {
            duplicatePairs++;
        }
        
        // Shrink window if we have more than 1 duplicate pair
        while (duplicatePairs > 1) {
            if (s[left] == s[left + 1]) {
                duplicatePairs--;
            }
            left++;
        }
        
        // Update maximum length
        int currentLength = right - left + 1;
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each character is processed at most twice (once by right pointer, once by left pointer)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track pointers and counts

✓ Linear Space

28.5K Views

Medium Frequency

~18 min Avg. Time

892 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 (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler