Merge branch 'master' into master

Author: Vasundhara117

spotbugs-exclude.xml

@@ -11,9 +11,6 @@
     <Match>
         <Bug pattern="RV_RETURN_VALUE_IGNORED_NO_SIDE_EFFECT" />
     </Match>
-    <Match>
-        <Bug pattern="DM_NEXTINT_VIA_NEXTDOUBLE" />
-    </Match>
     <Match>
         <Bug pattern="EI_EXPOSE_REP" />
     </Match>
@@ -99,9 +96,6 @@
     <Match>
         <Bug pattern="UCPM_USE_CHARACTER_PARAMETERIZED_METHOD" />
     </Match>
-    <Match>
-        <Bug pattern="SUA_SUSPICIOUS_UNINITIALIZED_ARRAY" />
-    </Match>
     <Match>
         <Bug pattern="SPP_USE_MATH_CONSTANT" />
     </Match>

src/main/java/com/thealgorithms/divideandconquer/ClosestPair.java

@@ -66,10 +66,6 @@ public static class Location {
         }
     }
 
-    public Location[] createLocation(int numberValues) {
-        return new Location[numberValues];
-    }
-
     public Location buildLocation(double x, double y) {
         return new Location(x, y);
     }

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

@@ -13,6 +13,12 @@ private LongestNonRepetitiveSubstring() {
     /**
      * Finds the length of the longest substring without repeating characters.
      *
+     * Uses the sliding window technique with a HashMap to track
+     * the last seen index of each character.
+     *
+     * Time Complexity: O(n), where n is the length of the input string.
+     * Space Complexity: O(min(n, m)), where m is the size of the character set.
+     *
      * @param s the input string
      * @return the length of the longest non-repetitive substring
      */

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/divideandconquer/ClosestPairTest.java

@@ -16,14 +16,6 @@ public void testBuildLocation() {
         assertEquals(4.0, point.y);
     }
 
-    @Test
-    public void testCreateLocation() {
-        ClosestPair cp = new ClosestPair(5);
-        ClosestPair.Location[] locations = cp.createLocation(5);
-        assertNotNull(locations);
-        assertEquals(5, locations.length);
-    }
-
     @Test
     public void testXPartition() {
         ClosestPair cp = new ClosestPair(5);

src/test/java/com/thealgorithms/searches/LinearSearchThreadTest.java

@@ -3,6 +3,7 @@
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import java.util.Random;
 import org.junit.jupiter.api.Test;
 
 class LinearSearchThreadTest {
@@ -62,10 +63,11 @@ void testSearcherEmptySegment() throws InterruptedException {
     void testSearcherRandomNumbers() throws InterruptedException {
         int size = 200;
         int[] array = new int[size];
+        Random random = new Random();
         for (int i = 0; i < size; i++) {
-            array[i] = (int) (Math.random() * 100);
+            array[i] = random.nextInt(100);
         }
-        int target = array[(int) (Math.random() * size)]; // Randomly select a target that is present
+        final int target = array[random.nextInt(size)]; // Randomly select a target that is present
         Searcher searcher = new Searcher(array, 0, size, target);
         searcher.start();
         searcher.join();

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}));
+    }
+}