Codestin Search App

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.

Constraints

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

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.

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
✓ Brute Force (Check All Substrings)	O(n³)	O(n³)	Generate all substrings and check for duplicates
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) — Algorithm Steps

For each possible substring length from n-1 down to 1
Generate all substrings of that length
Use a hash set to detect duplicates
Return the first (longest) duplicate found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Length n-1

Check all substrings of length n-1 for duplicates

Try Length n-2

If no duplicates found, try shorter substrings

Continue Until Found

Keep reducing length until duplicate found

Code -

solution.c — C

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

char* longestDupSubstring(char* s) {
    int n = strlen(s);
    char* result = malloc(n + 1);
    result[0] = '\0';
    
    // Try all possible lengths from longest to shortest
    for (int length = n - 1; length > 0; length--) {
        for (int i = 0; i <= n - length; i++) {
            for (int j = i + 1; j <= n - length; j++) {
                if (strncmp(s + i, s + j, length) == 0) {
                    strncpy(result, s + i, length);
                    result[length] = '\0';
                    return result;
                }
            }
        }
    }
    
    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³)

O(n²) substrings, each taking O(n) time to compare/hash

⚠ Quadratic Growth

Space Complexity

O(n³)

Storing all possible substrings in hash set

⚠ Quadratic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler