Longest Duplicate Substring - Practice Coding Problems

Longest Duplicate Substring - Problem

String Binary Search Sliding Window Rolling Hash Suffix Array Hash Function Hard

Find the Longest Duplicate Substring

You're given a string s and need to find the longest substring that appears at least twice in the string. The duplicate occurrences can overlap with each other.

Goal: Return any duplicate substring with the maximum possible length. If no duplicates exist, return an empty string "".

Example: In the string "banana", both "an" and "ana" appear twice, but "ana" is longer, so we return "ana".

This problem tests your understanding of string processing, hashing techniques, and binary search optimization.

Input & Output

example_1.py — Basic Duplicate

$ Input: s = "banana"

› Output: "ana"

💡 Note: Both "an" and "ana" appear twice in "banana", but "ana" is longer so we return it. The duplicates are at positions (1-3) and (3-5).

example_2.py — No Duplicates

$ Input: s = "abcd"

› Output: ""

💡 Note: All characters are unique, so no substring appears more than once. Return empty string.

example_3.py — Overlapping Duplicates

$ Input: s = "aa"

› Output: "a"

💡 Note: The character "a" appears twice (overlapping is allowed). This is the longest possible duplicate.

Visualization

Tap to expand

Understanding the Visualization

Set Search Range

Binary search between minimum (0) and maximum possible duplicate length (n-1)

Test Middle Length

For the middle length, use rolling hash to check all substrings of that length

Rolling Hash Magic

Calculate hash in O(1) time for each new substring by removing leftmost and adding rightmost character

Duplicate Detection

If same hash appears twice, verify it's a real match (not just hash collision)

Adjust Search

If duplicates found, try longer lengths; otherwise try shorter lengths

Key Takeaway

🎯 Key Insight: Binary search narrows down the optimal length efficiently, while rolling hash avoids expensive string comparisons by computing hashes in constant time.

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Binary search O(log n) times, each taking O(n²) for rolling hash

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set to store rolling hash values

⚡ Linearithmic Space

Constraints

2 ≤ s.length ≤ 3 × 10⁴
s consists of lowercase English letters only
Time limit: Solution must run efficiently for maximum constraints

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses binary search to find the maximum duplicate length combined with rolling hash (Rabin-Karp) to efficiently check for duplicates. This achieves O(n² log n) time complexity, much better than the O(n³) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Rolling Hash (Optimal)	O(n² log n)	O(n)	Binary search on answer length with rolling hash for efficiency
Brute Force (Check All Substrings)	O(n³)	O(n³)	Generate all substrings and check for duplicates

Binary Search + Rolling Hash (Optimal) — Algorithm Steps

Binary search on the length of the duplicate substring
For each candidate length, use rolling hash to check all substrings
Rolling hash allows O(1) hash computation for each substring
If duplicates exist at current length, search for longer; otherwise search shorter
Return the longest duplicate found

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search Setup

Search space is [0, n-1] for possible duplicate lengths

Rolling Hash Check

For each length, use rolling hash to check all substrings efficiently

Adjust Search Space

If duplicates found, search longer; otherwise search shorter

Code -

solution.c — C

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

#define MOD 2147483647
#define BASE 26

typedef struct {
    long long hash;
    int pos;
} HashEntry;

char* search(char* s, int length, int n) {
    if (length == 0) return strdup("");
    
    long long hashVal = 0;
    long long coeff = 1;
    
    // Calculate hash of first substring and coefficient
    for (int i = 0; i < length; i++) {
        hashVal = (hashVal * BASE + (s[i] - 'a')) % MOD;
        if (i < length - 1) coeff = (coeff * BASE) % MOD;
    }
    
    // Simple hash table using array
    HashEntry* seen = malloc(n * sizeof(HashEntry));
    int seenCount = 0;
    seen[seenCount++] = (HashEntry){hashVal, 0};
    
    for (int i = 1; i <= n - length; i++) {
        // Rolling hash
        hashVal = (hashVal - (s[i-1] - 'a') * coeff % MOD + MOD) % MOD;
        hashVal = (hashVal * BASE + (s[i + length - 1] - 'a')) % MOD;
        
        // Check if hash exists
        for (int j = 0; j < seenCount; j++) {
            if (seen[j].hash == hashVal) {
                if (strncmp(s + seen[j].pos, s + i, length) == 0) {
                    char* result = malloc(length + 1);
                    strncpy(result, s + i, length);
                    result[length] = '\0';
                    free(seen);
                    return result;
                }
            }
        }
        
        seen[seenCount++] = (HashEntry){hashVal, i};
    }
    
    free(seen);
    return strdup("");
}

char* longestDupSubstring(char* s) {
    int n = strlen(s);
    int left = 0, right = n - 1;
    char* result = strdup("");
    
    while (left <= right) {
        int mid = (left + right) / 2;
        char* dup = search(s, mid, n);
        
        if (strlen(dup) > 0) {
            free(result);
            result = dup;
            left = mid + 1;
        } else {
            free(dup);
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    // Remove quotes
    char* start = s;
    if (*start == '"') start++;
    int len = strlen(start);
    if (len > 0 && start[len-1] == '"') start[len-1] = '\0';
    
    char* result = longestDupSubstring(start);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² log n)

Binary search O(log n) times, each taking O(n²) for rolling hash

⚠ Quadratic Growth

Space Complexity

O(n)

Hash set to store rolling hash values

⚡ Linearithmic Space

Constraints

2 ≤ s.length ≤ 3 × 10⁴
s consists of lowercase English letters only
Time limit: Solution must run efficiently for maximum constraints

67.0K Views

Medium Frequency

~35 min Avg. Time

1.9K 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 + Rolling Hash (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler