Find the Longest Semi-Repetitive Substring

Find the Longest Semi-Repetitive Substring - Problem

You are given a digit string s that consists of digits from 0 to 9.

A string is called semi-repetitive if there is at most one adjacent pair of the same digit. For example, "0010", "002020", "0123", "2002", and "54944" are semi-repetitive while the following are not: "00101022" (adjacent same digit pairs are 00 and 22), and "1101234883" (adjacent same digit pairs are 11 and 88).

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

Input & Output

Example 1 — Basic Case

$ Input: s = "52233"

› Output: 4

💡 Note: The longest semi-repetitive substring is "5223" with length 4. It has exactly one adjacent pair (2,2).

Example 2 — No Adjacent Pairs

$ Input: s = "5494"

› Output: 4

💡 Note: The entire string "5494" has no adjacent pairs, so it's completely semi-repetitive with length 4.

Example 3 — Multiple Pairs

$ Input: s = "1111"

› Output: 2

💡 Note: Any substring longer than 2 would have more than one adjacent pair. Maximum is "11" with length 2.

Constraints

1 ≤ s.length ≤ 1000
s consists of digits from 0 to 9

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 15

The key insight is to use a sliding window approach to maintain at most one adjacent pair. Best approach is sliding window with O(n) time and O(1) space complexity.

Common Approaches

✓ Brute Force

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

Generate every possible substring and check if it's semi-repetitive by counting adjacent pairs. Keep track of the maximum length found.

Sliding Window

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

Maintain a sliding window that expands when valid and contracts when we exceed one adjacent pair. Track the maximum window size encountered.

Brute Force — Algorithm Steps

Generate all possible substrings
For each substring, count adjacent same digit pairs
Keep the longest substring with at most 1 adjacent pair

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings

Count Adjacent Pairs

Check each substring for adjacent same digits

Track Maximum

Keep the longest valid substring

Code -

solution.c — C

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

int solution(char* s) {
    int n = strlen(s);
    int maxLen = 1;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            int adjacentPairs = 0;
            
            for (int k = i; k < j - 1; k++) {
                if (s[k] == s[k + 1]) {
                    adjacentPairs++;
                }
            }
            
            if (adjacentPairs <= 1) {
                int len = j - i;
                if (len > maxLen) {
                    maxLen = len;
                }
            }
        }
    }
    
    return maxLen;
}

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³)

O(n²) substrings, each taking O(n) time to check

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track counts and maximum

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

245 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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler