Add Longest Repeated Substring algorithm (#7286)

* Add Longest Repeated Substring algorithm

Implement LongestRepeatedSubstring in the strings package using the
existing SuffixArray and Kasai's algorithm for LCP array construction.
Includes parameterized unit tests covering typical and edge cases.

* style: reformat test file per clang-format and add coverage test

---------

Co-authored-by: Çağlar Eker <eker.caglar@hepsiburada.com>

Author: caglareker

src/main/java/com/thealgorithms/strings/LongestRepeatedSubstring.java

@@ -0,0 +1,83 @@
+package com.thealgorithms.strings;
+
+/**
+ * Finds the longest substring that occurs at least twice in a given string.
+ *
+ * <p>Uses the suffix array (via {@link SuffixArray}) and Kasai's algorithm
+ * to build the LCP (Longest Common Prefix) array, then returns the substring
+ * corresponding to the maximum LCP value.</p>
+ *
+ * <p>Time complexity: O(n log² n) for suffix array construction + O(n) for LCP.</p>
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Longest_repeated_substring_problem">Longest repeated substring problem</a>
+ * @see SuffixArray
+ */
+public final class LongestRepeatedSubstring {
+
+    private LongestRepeatedSubstring() {
+    }
+
+    /**
+     * Returns the longest substring that appears at least twice in the given text.
+     *
+     * @param text the input string
+     * @return the longest repeated substring, or an empty string if none exists
+     */
+    public static String longestRepeatedSubstring(String text) {
+        if (text == null || text.length() <= 1) {
+            return "";
+        }
+
+        final int[] suffixArray = SuffixArray.buildSuffixArray(text);
+        final int[] lcp = buildLcpArray(text, suffixArray);
+
+        int maxLen = 0;
+        int maxIdx = 0;
+        for (int i = 0; i < lcp.length; i++) {
+            if (lcp[i] > maxLen) {
+                maxLen = lcp[i];
+                maxIdx = suffixArray[i + 1];
+            }
+        }
+
+        return text.substring(maxIdx, maxIdx + maxLen);
+    }
+
+    /**
+     * Builds the LCP (Longest Common Prefix) array using Kasai's algorithm.
+     *
+     * <p>LCP[i] is the length of the longest common prefix between the suffixes
+     * at positions suffixArray[i] and suffixArray[i+1] in sorted order.</p>
+     *
+     * @param text the original string
+     * @param suffixArray the suffix array of the string
+     * @return the LCP array of length n-1
+     */
+    static int[] buildLcpArray(String text, int[] suffixArray) {
+        final int n = text.length();
+        final int[] rank = new int[n];
+        final int[] lcp = new int[n - 1];
+
+        for (int i = 0; i < n; i++) {
+            rank[suffixArray[i]] = i;
+        }
+
+        int k = 0;
+        for (int i = 0; i < n; i++) {
+            if (rank[i] == n - 1) {
+                k = 0;
+                continue;
+            }
+            final int j = suffixArray[rank[i] + 1];
+            while (i + k < n && j + k < n && text.charAt(i + k) == text.charAt(j + k)) {
+                k++;
+            }
+            lcp[rank[i]] = k;
+            if (k > 0) {
+                k--;
+            }
+        }
+
+        return lcp;
+    }
+}

src/test/java/com/thealgorithms/strings/LongestRepeatedSubstringTest.java

@@ -0,0 +1,33 @@
+package com.thealgorithms.strings;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class LongestRepeatedSubstringTest {
+
+    @ParameterizedTest(name = "\"{0}\" -> \"{1}\"")
+    @MethodSource("provideTestCases")
+    void testLongestRepeatedSubstring(String input, String expected) {
+        assertEquals(expected, LongestRepeatedSubstring.longestRepeatedSubstring(input));
+    }
+
+    private static Stream<Arguments> provideTestCases() {
+        return Stream.of(Arguments.of("banana", "ana"), Arguments.of("abcabc", "abc"), Arguments.of("aaaa", "aaa"), Arguments.of("abcd", ""), Arguments.of("a", ""), Arguments.of("", ""), Arguments.of(null, ""), Arguments.of("aab", "a"), Arguments.of("aa", "a"), Arguments.of("mississippi", "issi"));
+    }
+
+    @ParameterizedTest(name = "\"{0}\" -> LCP={1}")
+    @MethodSource("provideLcpTestCases")
+    void testBuildLcpArray(String input, int[] expectedLcp) {
+        int[] suffixArray = SuffixArray.buildSuffixArray(input);
+        assertArrayEquals(expectedLcp, LongestRepeatedSubstring.buildLcpArray(input, suffixArray));
+    }
+
+    private static Stream<Arguments> provideLcpTestCases() {
+        return Stream.of(Arguments.of("banana", new int[] {1, 3, 0, 0, 2}), Arguments.of("ab", new int[] {0}));
+    }
+}