Merge branch 'master' into patch-1

Author: rajattiwariind

src/main/java/com/thealgorithms/searches/JumpSearch.java

@@ -56,7 +56,7 @@
  * @see BinarySearch
  * @see LinearSearch
  */
-public class JumpSearch implements SearchAlgorithm {
+public final class JumpSearch implements SearchAlgorithm {
 
     /**
      * Jump Search algorithm implementation.
@@ -67,6 +67,10 @@ public class JumpSearch implements SearchAlgorithm {
      */
     @Override
     public <T extends Comparable<T>> int find(T[] array, T key) {
+        if (array == null || array.length == 0 || key == null) {
+            return -1;
+        }
+
         int length = array.length;
         int blockSize = (int) Math.sqrt(length);
 
@@ -78,7 +82,7 @@ public <T extends Comparable<T>> int find(T[] array, T key) {
 
         // Perform linear search within the identified block
         for (int i = limit - blockSize; i <= limit && i < length; i++) {
-            if (array[i].equals(key)) {
+            if (array[i] != null && key.compareTo(array[i]) == 0) {
                 return i;
             }
         }

src/main/java/com/thealgorithms/searches/SearchInARowAndColWiseSortedMatrix.java

@@ -1,32 +1,42 @@
-package com.thealgorithms.searches;
-
-public class SearchInARowAndColWiseSortedMatrix {
-    /**
-     * Search a key in row and column wise sorted matrix
-     *
-     * @param matrix matrix to be searched
-     * @param value  Key being searched for
-     * @author Sadiul Hakim : https://github.com/sadiul-hakim
-     */
-    public int[] search(int[][] matrix, int value) {
-        int n = matrix.length;
-        // This variable iterates over rows
-        int i = 0;
-        // This variable iterates over columns
-        int j = n - 1;
-        int[] result = {-1, -1};
-        while (i < n && j >= 0) {
-            if (matrix[i][j] == value) {
-                result[0] = i;
-                result[1] = j;
-                return result;
-            }
-            if (value > matrix[i][j]) {
-                i++;
-            } else {
-                j--;
-            }
-        }
-        return result;
-    }
-}
+package com.thealgorithms.searches;
+
+public final class SearchInARowAndColWiseSortedMatrix {
+    /**
+     * Search a key in row and column wise sorted matrix
+     *
+     * @param matrix matrix to be searched
+     * @param value  Key being searched for
+     * @return row and column indices if found, otherwise {-1, -1}
+     * @author Sadiul Hakim : https://github.com/sadiul-hakim
+     */
+    public int[] search(int[][] matrix, int value) {
+        if (matrix == null || matrix.length == 0 || matrix[0] == null || matrix[0].length == 0) {
+            return new int[] {-1, -1};
+        }
+
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+        // This variable iterates over rows
+        int i = 0;
+        // This variable iterates over columns, starting from top-right corner
+        int j = cols - 1;
+        int[] result = {-1, -1};
+        while (i < rows && j >= 0) {
+            if (matrix[i] == null || j >= matrix[i].length) {
+                i++;
+                continue;
+            }
+            if (matrix[i][j] == value) {
+                result[0] = i;
+                result[1] = j;
+                return result;
+            }
+            if (value > matrix[i][j]) {
+                i++;
+            } else {
+                j--;
+            }
+        }
+        return result;
+    }
+}

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

@@ -0,0 +1,69 @@
+package com.thealgorithms.strings;
+
+/**
+ * Finds the lexicographically smallest cyclic rotation of a string using
+ * Booth's algorithm.
+ *
+ * <p>The algorithm compares candidate rotations without materializing them,
+ * running in O(n) time and O(1) auxiliary space.</p>
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Lexicographically_minimal_string_rotation">
+ *     Lexicographically minimal string rotation</a>
+ */
+public final class BoothsAlgorithm {
+    private BoothsAlgorithm() {
+    }
+
+    /**
+     * Returns the starting index of the lexicographically smallest cyclic
+     * rotation of {@code input}. If several rotations are equal and minimal,
+     * the algorithm returns the smallest starting index among them.
+     *
+     * <p>For example, the smallest rotation of {@code "baca"} is
+     * {@code "abac"}, which starts at index {@code 3}.</p>
+     *
+     * @param input the string whose minimal cyclic rotation is sought
+     * @return the starting index of the minimal rotation, or {@code 0} for an
+     *         empty string
+     * @throws IllegalArgumentException if {@code input} is {@code null}
+     */
+    public static int minimalRotationIndex(String input) {
+        if (input == null) {
+            throw new IllegalArgumentException("Input string must not be null");
+        }
+
+        int length = input.length();
+        if (length == 0) {
+            return 0;
+        }
+
+        int first = 0;
+        int second = 1;
+        int offset = 0;
+
+        while (first < length && second < length && offset < length) {
+            char firstChar = input.charAt((first + offset) % length);
+            char secondChar = input.charAt((second + offset) % length);
+
+            if (firstChar == secondChar) {
+                offset++;
+                continue;
+            }
+
+            if (firstChar > secondChar) {
+                first += offset + 1;
+                if (first <= second) {
+                    first = second + 1;
+                }
+            } else {
+                second += offset + 1;
+                if (second <= first) {
+                    second = first + 1;
+                }
+            }
+            offset = 0;
+        }
+
+        return Math.min(first, second);
+    }
+}

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

@@ -139,4 +139,40 @@ void testJumpSearchFindsEveryElement() {
             }
         }
     }
+
+    @Test
+    void testJumpSearchNullArray() {
+        JumpSearch jumpSearch = new JumpSearch();
+        assertEquals(-1, jumpSearch.find(null, 5), "Searching in a null array should return -1.");
+    }
+
+    @Test
+    void testJumpSearchNullKey() {
+        JumpSearch jumpSearch = new JumpSearch();
+        Integer[] array = {1, 2, 3};
+        assertEquals(-1, jumpSearch.find(array, null), "Searching for a null key should return -1.");
+    }
+
+    @Test
+    void testJumpSearchSingleElementAbsent() {
+        JumpSearch jumpSearch = new JumpSearch();
+        Integer[] array = {10};
+        assertEquals(-1, jumpSearch.find(array, 5), "Searching for an absent key in single element array should return -1.");
+    }
+
+    @Test
+    void testJumpSearchStringArray() {
+        JumpSearch jumpSearch = new JumpSearch();
+        String[] array = {"apple", "banana", "cherry", "date", "elderberry"};
+        assertEquals(2, jumpSearch.find(array, "cherry"), "The index of 'cherry' should be 2.");
+        assertEquals(-1, jumpSearch.find(array, "fig"), "Key 'fig' should not be found.");
+    }
+
+    @Test
+    void testJumpSearchDuplicates() {
+        JumpSearch jumpSearch = new JumpSearch();
+        Integer[] array = {1, 2, 2, 2, 3, 4, 5};
+        int index = jumpSearch.find(array, 2);
+        assertEquals(2, array[index], "The element at the returned index should equal the target key.");
+    }
 }

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

@@ -63,4 +63,36 @@ void testSearchInColWiseSortedMatrix() {
         int[] expected = {1, 1}; // Found at (1, 1)
         assertArrayEquals(expected, searcher.search(matrix, value), "Value should be found in the column-wise sorted matrix");
     }
+
+    @Test
+    void testSearchInNullMatrix() {
+        assertArrayEquals(new int[] {-1, -1}, searcher.search(null, 5), "Should return {-1, -1} for null matrix");
+    }
+
+    @Test
+    void testSearchInMatrixWithEmptyRows() {
+        int[][] matrix = {{}};
+        assertArrayEquals(new int[] {-1, -1}, searcher.search(matrix, 5), "Should return {-1, -1} for matrix with empty first row");
+    }
+
+    @Test
+    void testSearchInRectangularMatrixMoreColsThanRowsFound() {
+        int[][] matrix = {{1, 3, 5, 7, 9}, {2, 4, 6, 8, 10}};
+        int[] expected = {0, 4}; // Value 9 is at row 0, col 4
+        assertArrayEquals(expected, searcher.search(matrix, 9), "Value 9 should be found at row 0, col 4");
+    }
+
+    @Test
+    void testSearchInRectangularMatrixMoreRowsThanColsFound() {
+        int[][] matrix = {{1, 5}, {2, 6}, {3, 7}, {4, 8}};
+        int[] expected = {2, 0}; // Value 3 is at row 2, col 0
+        assertArrayEquals(expected, searcher.search(matrix, 3), "Value 3 should be found at row 2, col 0");
+    }
+
+    @Test
+    void testSearchInRectangularMatrixNotFound() {
+        int[][] matrix = {{1, 3, 5}, {2, 4, 6}, {7, 8, 9}, {10, 11, 12}};
+        int[] expected = {-1, -1};
+        assertArrayEquals(expected, searcher.search(matrix, 15), "Value 15 should not be found");
+    }
 }

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

@@ -0,0 +1,45 @@
+package com.thealgorithms.strings;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+public class BoothsAlgorithmTest {
+
+    @Test
+    public void testMinimalRotationIndexForExample() {
+        assertEquals(3, BoothsAlgorithm.minimalRotationIndex("baca"));
+    }
+
+    @Test
+    public void testEmptyString() {
+        assertEquals(0, BoothsAlgorithm.minimalRotationIndex(""));
+    }
+
+    @Test
+    public void testSingleCharacter() {
+        assertEquals(0, BoothsAlgorithm.minimalRotationIndex("x"));
+    }
+
+    @Test
+    public void testRepeatedCharacters() {
+        assertEquals(0, BoothsAlgorithm.minimalRotationIndex("aaaaa"));
+    }
+
+    @Test
+    public void testPeriodicString() {
+        assertEquals(1, BoothsAlgorithm.minimalRotationIndex("baba"));
+        assertEquals(1, BoothsAlgorithm.minimalRotationIndex("cabcab"));
+    }
+
+    @Test
+    public void testStringAlreadyHasMinimalRotationAtStart() {
+        assertEquals(0, BoothsAlgorithm.minimalRotationIndex("abc"));
+    }
+
+    @Test
+    public void testNullInput() {
+        assertThrows(IllegalArgumentException.class, () -> BoothsAlgorithm.minimalRotationIndex(null));
+    }
+}