Longest Repeating Substring - Practice Coding Problems

Longest Repeating Substring - Problem

String Binary Search Dynamic Programming Rolling Hash Suffix Array Hash Function Medium

Given a string s, find the length of the longest repeating substring. A repeating substring is one that appears at least twice in the string (possibly overlapping).

For example, in the string "abcabc", the substring "abc" appears twice, so the answer would be 3. In "aabaaaba", the substring "aaba" appears twice (overlapping), so the answer would be 4.

If no substring repeats, return 0.

Goal: Find the maximum length of any substring that occurs at least twice in the input string.

Input & Output

example_1.py — Basic Repeat

$ Input: s = "abab"

› Output: 2

💡 Note: The substring "ab" appears twice: at positions 0-1 and 2-3. This is the longest repeating substring.

example_2.py — Overlapping Repeat

$ Input: s = "aabaaaba"

› Output: 4

💡 Note: The substring "aaba" appears twice with overlap: at positions 0-3 and 4-7. Even though they overlap, they count as repeats.

example_3.py — No Repeats

$ Input: s = "abcdef"

› Output: 0

💡 Note: No substring appears more than once in this string, so the answer is 0.

Visualization

Tap to expand

Understanding the Visualization

Shout different phrases

Try phrases of different lengths (binary search)

Listen for echoes

Use rolling hash to quickly identify matching sound patterns

Find the longest echo

The longest phrase that echoes back is our answer

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with rolling hash allows us to efficiently find the longest repeating substring without checking every possible substring individually.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to check each substring occurrence

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing the maximum length, no extra data structures

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of only lowercase English letters
Time limit: 2 seconds

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses binary search combined with rolling hash to achieve O(n log n) time complexity. We binary search on the possible answer length and use rolling hash to efficiently check if any substring of that length appears more than once.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring to see if it appears again later
Binary Search + Rolling Hash (Optimal)	O(n log n)	O(n)	Binary search on answer length with rolling hash for fast substring comparison

Brute Force (Check All Substrings) — Algorithm Steps

Generate all possible substrings starting from longest to shortest
For each substring, search for its occurrence elsewhere in the string
If found, update maximum length and potentially return early
Continue until all substrings are checked

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with longest possible substring

Begin checking substrings of length n-1

Check each position

For each substring, scan the rest of the string for matches

Compare character by character

When potential match found, compare all characters

Return first match

Since we start with longest, first match is the answer

Code -

solution.c — C

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

int longestRepeatingSubstring(char* s) {
    int n = strlen(s);
    
    // Try all possible substring lengths from longest to shortest
    for (int length = n - 1; length > 0; length--) {
        // Try all possible starting positions for this length
        for (int i = 0; i <= n - length; i++) {
            // Look for this substring starting from position i + 1
            for (int j = i + 1; j <= n - length; j++) {
                if (strncmp(s + i, s + j, length) == 0) {
                    return length;
                }
            }
        }
    }
    
    return 0;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        int len = strlen(s);
        memmove(s, s + 1, len - 2);
        s[len - 2] = '\0';
    }
    printf("%d\n", longestRepeatingSubstring(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) substrings × O(n) to check each substring occurrence

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing the maximum length, no extra data structures

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of only lowercase English letters
Time limit: 2 seconds

28.4K Views

Medium Frequency

~25 min Avg. Time

875 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

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler