Suffix Array Builder - Problem

A suffix array is a sorted array of all suffixes of a given string. For example, for string "banana", the suffixes are ["banana", "anana", "nana", "ana", "na", "a"], and the suffix array contains the indices of these suffixes in lexicographically sorted order.

Your task is to:

Build a suffix array for the given string in O(n log n) time complexity
Find the longest repeated substring using the suffix array

Return the longest repeated substring. If there are multiple substrings of the same maximum length, return the lexicographically smallest one.

Note: A repeated substring must appear at least twice in the string.

Input & Output

Example 1 — Classic Case

$ Input: s = "banana"

› Output: "ana"

💡 Note: The suffixes are ["banana", "anana", "nana", "ana", "na", "a"]. After sorting: ["a", "ana", "anana", "banana", "na", "nana"]. The longest common prefix between adjacent suffixes "ana" and "anana" is "ana" with length 3.

Example 2 — Multiple Repetitions

$ Input: s = "abcabc"

› Output: "abc"

💡 Note: The string contains "abc" repeated twice. The suffix array helps identify this as the longest repeated substring with length 3.

Example 3 — No Repetition

$ Input: s = "abcd"

› Output: ""

💡 Note: All characters are unique, so no substring repeats. The longest repeated substring is empty.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 M Microsoft 35 a Amazon 30 f Meta 25

Build a suffix array by sorting all suffixes of the string, then find the longest common prefix (LCP) between adjacent entries. The optimal approach uses radix sorting to achieve O(n log n) time complexity. Key insight: sorting suffixes brings repeated patterns together as neighbors. Time: O(n log n), Space: O(n)

Common Approaches

✓ Brute Force - Check All Substrings

⏱️ Time: O(n⁴) Space: O(1)

Generate every possible substring of the input string and for each substring, search through the entire string to count its occurrences. Keep track of the longest substring that appears at least twice.

Radix Sort Suffix Array - O(n log n)

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

Build suffix array in O(n log n) using radix sorting technique that compares suffixes by doubling comparison length in each iteration (1-char, 2-char, 4-char, etc.) instead of doing full string comparisons.

Suffix Array with Naive Sorting

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

Create all suffixes of the string, sort them lexicographically using built-in string comparison, then scan adjacent suffixes in the sorted array to find the longest common prefix between consecutive entries.

Brute Force - Check All Substrings — Algorithm Steps

Step 1: Generate all possible substrings of length 1 to n
Step 2: For each substring, count occurrences in the original string
Step 3: Track the longest substring that appears at least twice
Step 4: Return the lexicographically smallest among longest repeated substrings

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Create all possible substrings from the input string

Count Occurrences

For each substring, scan entire string to count repetitions

Track Longest

Keep the longest substring that appears at least twice

Code -

solution.c — C

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

char* solution(char* s) {
    int n = strlen(s);
    char* longest = malloc(n + 1);
    longest[0] = '\0';
    
    // Check all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            char substring[1001];
            strncpy(substring, s + i, j - i);
            substring[j - i] = '\0';
            int count = 0;
            int sublen = strlen(substring);
            
            // Count occurrences of this substring
            for (int k = 0; k <= n - sublen; k++) {
                if (strncmp(s + k, substring, sublen) == 0) {
                    count++;
                }
            }
            
            // Update longest if this substring appears at least twice
            if (count >= 2) {
                if (sublen > strlen(longest) || 
                   (sublen == strlen(longest) && strcmp(substring, longest) < 0)) {
                    strcpy(longest, substring);
                }
            }
        }
    }
    
    return longest;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n²) to generate all substrings, O(n²) to search for each substring in the text

⚡ Linearithmic

Space Complexity

O(1)

Only using variables to track current and longest substring

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~35 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

Suffix Array Builder - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Substrings — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler