Maximum Repeating Substring - Practice Coding Problems

Maximum Repeating Substring - Problem

Maximum Repeating Substring

Given two strings sequence and word, you need to find the maximum k-repeating value of word in sequence.

A string word is k-repeating if word concatenated k times is a substring of sequence. For example, if word = "ab" and sequence = "ababab", then word is 3-repeating because "ab" + "ab" + "ab" = "ababab" is found in the sequence.

Your task is to return the highest value k where word repeated k times appears as a substring in sequence. If word is not a substring of sequence at all, return 0.

Example:
• sequence = "ababc", word = "ab" → return 2
• Because "abab" (ab repeated 2 times) is in sequence, but "ababab" is not

Input & Output

example_1.py — Basic Case

$ Input: sequence = "ababc", word = "ab"

› Output: 2

💡 Note: The word "ab" repeats 2 times as "abab" which is found in "ababc". "ab" repeated 3 times would be "ababab" which is not found in the sequence.

example_2.py — No Repetition

$ Input: sequence = "ababc", word = "ba"

› Output: 1

💡 Note: The word "ba" appears once in "ababc" but "baba" does not appear, so maximum k is 1.

example_3.py — Word Not Found

$ Input: sequence = "ababc", word = "ac"

› Output: 0

💡 Note: The word "ac" is not found in "ababc" at all, so the maximum k-repeating value is 0.

Visualization

Tap to expand

Understanding the Visualization

Start with single word

Begin by looking for the word once in the sequence

Extend the pattern

Add the word to our pattern and check if this longer repetition exists

Continue until failure

Keep extending until we can't find the pattern anymore

Return maximum found

The last successful k value is our answer

Key Takeaway

🎯 Key Insight: By building the pattern incrementally and stopping at the first failure, we efficiently find the maximum repetitions without unnecessary work.

Time & Space Complexity

Time Complexity

⏱️

O(n * k)

Where n = len(sequence), k = actual maximum repeats. We do k substring searches, each taking O(n) time

✓ Linear Growth

Space Complexity

O(k * m)

Space for the repeated word string, which grows to k*m where m = len(word)

✓ Linear Space

Constraints

1 ≤ sequence.length ≤ 100
1 ≤ word.length ≤ 100
sequence and word contain only lowercase English letters

Asked in

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

The optimal solution uses an incremental building approach with O(n * k) time complexity. Instead of checking all possible k values separately, we incrementally build the repeated word and stop as soon as we can't find a match. This is more efficient than the brute force approach and simpler than binary search for this problem size.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer	O(n * m * log k)	O(k * m)	Use binary search to find the maximum k value efficiently
Incremental Building (Optimal)	O(n * k)	O(k * m)	Build repeated word incrementally and check existence until no match found
Brute Force (Check All Possible k)	O(n * m * k)	O(k * m)	Try every possible k value from 1 to maximum possible and check if k-repeated word exists

Binary Search on Answer — Algorithm Steps

Set left = 0, right = len(sequence) // len(word)
While left < right:
- mid = (left + right + 1) // 2
- If word repeated mid times is in sequence:
- left = mid (search for larger k)
- Else: right = mid - 1 (search for smaller k)
Return left

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial range

left=0, right=2, mid=2: Can 'abab' repeat 2 times? No

Narrow down

left=0, right=1, mid=1: Can 'ab' repeat 1 time? Yes

Found answer

left=1, right=1: Answer is 1

Code -

solution.c — C

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

int canRepeat(char* sequence, char* word, int k) {
    if (k == 0) return 1;
    
    int wordLen = strlen(word);
    char* repeated = malloc((k * wordLen + 1) * sizeof(char));
    repeated[0] = '\0';
    
    for (int i = 0; i < k; i++) {
        strcat(repeated, word);
    }
    
    int result = (strstr(sequence, repeated) != NULL);
    free(repeated);
    return result;
}

int maxRepeating(char* sequence, char* word) {
    int seqLen = strlen(sequence);
    int wordLen = strlen(word);
    
    if (wordLen == 0 || seqLen == 0) return 0;
    
    int left = 0, right = seqLen / wordLen;
    
    while (left < right) {
        int mid = (left + right + 1) / 2;
        if (canRepeat(sequence, word, mid)) {
            left = mid;
        } else {
            right = mid - 1;
        }
    }
    
    return left;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n * m * log k)

Where n = len(sequence), m = len(word), k = max possible repeats. We do O(log k) iterations, each checking substring of length up to k*m

⚡ Linearithmic

Space Complexity

O(k * m)

Space for the repeated word string in worst case

✓ Linear Space

Constraints

1 ≤ sequence.length ≤ 100
1 ≤ word.length ≤ 100
sequence and word contain only lowercase English letters

28.5K Views

Medium Frequency

~15 min Avg. Time

847 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler