Longest Repeating Substring

Longest Repeating Substring - Problem

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

Given a string s, return the length of the longest repeating substring. If no repeating substring exists, return 0.

A repeating substring is a substring that occurs at least twice in the string.

Input & Output

Example 1 — Basic Repeating Pattern

$ Input: s = "abcabc"

› Output: 3

💡 Note: The substring "abc" appears twice: at positions 0-2 and 3-5, so the longest repeating substring has length 3

Example 2 — Single Character Repetition

$ Input: s = "aabaaaba"

› Output: 4

💡 Note: The substring "aaba" appears at positions 0-3 and 4-7, so the longest repeating substring has length 4

Example 3 — No Repetition

$ Input: s = "abcdef"

› Output: 0

💡 Note: No substring appears more than once, so return 0

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 M Microsoft 15 f Facebook 12

The key insight is to compare the string with shifted versions of itself to find repeating patterns. The optimal approach uses binary search on the answer combined with rolling hash for efficient duplicate detection. Time: O(n log n), Space: O(n)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Binary Search + Rolling Hash

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

Binary search on the possible length of repeating substring (0 to n-1). For each length, use rolling hash to efficiently check if any substring of that length appears more than once.

Brute Force

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

Generate all possible substrings and check if each appears more than once in the string. Keep track of the maximum length found.

Dynamic Programming

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

Use a 2D DP table to compare every character of the string with every other character. Build up lengths of common substrings systematically.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int* nums, int n, int k) {
    if (n < k) return 0;
    
    // Group positions by remainder when divided by k
    int groups[k][n];
    int groupSizes[k];
    memset(groupSizes, 0, sizeof(groupSizes));
    
    for (int i = 0; i < n; i++) {
        int remainder = i % k;
        groups[remainder][groupSizes[remainder]++] = nums[i];
    }
    
    // For first k-1 groups, choose most frequent value
    int totalChanges = 0;
    int targetXor = 0;
    
    for (int g = 0; g < k - 1; g++) {
        if (groupSizes[g] == 0) continue;
        
        int freq[1024] = {0};
        for (int i = 0; i < groupSizes[g]; i++) {
            freq[groups[g][i]]++;
        }
        
        int maxFreq = 0;
        int bestVal = 0;
        for (int val = 0; val < 1024; val++) {
            if (freq[val] > maxFreq) {
                maxFreq = freq[val];
                bestVal = val;
            }
        }
        
        totalChanges += groupSizes[g] - maxFreq;
        targetXor ^= bestVal;
    }
    
    // Last group must have value targetXor to make total XOR = 0
    if (groupSizes[k-1] > 0) {
        int freq[1024] = {0};
        for (int i = 0; i < groupSizes[k-1]; i++) {
            freq[groups[k-1][i]]++;
        }
        totalChanges += groupSizes[k-1] - freq[targetXor];
    }
    
    return totalChanges;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int nums[1000], n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    int k;
    scanf("%d", &k);
    printf("%d\n", solution(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

35.0K Views

Medium Frequency

~25 min Avg. Time

890 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