Merge branch 'TheAlgorithms:master' into master

Author: GziXnine

pom.xml

@@ -127,7 +127,7 @@
                         <plugin>
                             <groupId>com.mebigfatguy.fb-contrib</groupId>
                             <artifactId>fb-contrib</artifactId>
-                            <version>7.7.2</version>
+                            <version>7.7.3</version>
                         </plugin>
                         <plugin>
                             <groupId>com.h3xstream.findsecbugs</groupId>

src/main/java/com/thealgorithms/maths/PerfectSquare.java

@@ -15,6 +15,9 @@ private PerfectSquare() {
      * <tt>false</tt>
      */
     public static boolean isPerfectSquare(final int number) {
+        if (number < 0) {
+            return false;
+        }
         final int sqrt = (int) Math.sqrt(number);
         return sqrt * sqrt == number;
     }
@@ -27,6 +30,9 @@ public static boolean isPerfectSquare(final int number) {
      * {@code false}
      */
     public static boolean isPerfectSquareUsingPow(long number) {
+        if (number < 0) {
+            return false;
+        }
         long a = (long) Math.pow(number, 1.0 / 2);
         return a * a == number;
     }

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

@@ -0,0 +1,60 @@
+package com.thealgorithms.searches;
+
+import com.thealgorithms.devutils.searches.SearchAlgorithm;
+
+/**
+ * Searches for a key in a sorted array that has been rotated at an unknown pivot.
+ *
+ * <p>
+ * Example:
+ * {@code [8, 9, 10, 1, 2, 3, 4, 5, 6, 7]}
+ *
+ * <p>
+ * This is a modified binary search. When the array contains no duplicates, the
+ * time complexity is {@code O(log n)}. With duplicates, the algorithm still
+ * works but may degrade to {@code O(n)} in the worst case.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Search_in_rotated_sorted_array">Search in rotated sorted array</a>
+ * @see SearchAlgorithm
+ */
+public final class RotatedBinarySearch implements SearchAlgorithm {
+
+    @Override
+    public <T extends Comparable<T>> int find(T[] array, T key) {
+        int left = 0;
+        int right = array.length - 1;
+
+        while (left <= right) {
+            int middle = (left + right) >>> 1;
+            int cmp = key.compareTo(array[middle]);
+            if (cmp == 0) {
+                return middle;
+            }
+
+            // Handle duplicates: if we cannot determine which side is sorted.
+            if (array[left].compareTo(array[middle]) == 0 && array[middle].compareTo(array[right]) == 0) {
+                left++;
+                right--;
+                continue;
+            }
+
+            // Left half is sorted.
+            if (array[left].compareTo(array[middle]) <= 0) {
+                if (array[left].compareTo(key) <= 0 && key.compareTo(array[middle]) < 0) {
+                    right = middle - 1;
+                } else {
+                    left = middle + 1;
+                }
+            } else {
+                // Right half is sorted.
+                if (array[middle].compareTo(key) < 0 && key.compareTo(array[right]) <= 0) {
+                    left = middle + 1;
+                } else {
+                    right = middle - 1;
+                }
+            }
+        }
+
+        return -1;
+    }
+}

src/main/java/com/thealgorithms/slidingwindow/CountNiceSubarrays.java

@@ -0,0 +1,99 @@
+package com.thealgorithms.slidingwindow;
+
+/**
+ * Counts the number of "nice subarrays".
+ * A nice subarray is a contiguous subarray that contains exactly k odd numbers.
+ *
+ * This implementation uses the sliding window technique.
+ *
+ * Reference:
+ * https://leetcode.com/problems/count-number-of-nice-subarrays/
+ *
+ * Time Complexity: O(n)
+ * Space Complexity: O(n)
+ */
+public final class CountNiceSubarrays {
+
+    // Private constructor to prevent instantiation
+    private CountNiceSubarrays() {
+    }
+
+    /**
+     * Returns the count of subarrays containing exactly k odd numbers.
+     *
+     * @param nums input array of integers
+     * @param k    number of odd elements required in the subarray
+     * @return number of nice subarrays
+     */
+    public static int countNiceSubarrays(int[] nums, int k) {
+
+        int n = nums.length;
+
+        // Left pointer of the sliding window
+        int left = 0;
+
+        // Tracks number of odd elements in the current window
+        int oddCount = 0;
+
+        // Final answer: total number of nice subarrays
+        int result = 0;
+
+        /*
+         * memo[i] stores how many valid starting positions exist
+         * when the left pointer is at index i.
+         *
+         * This avoids recomputing the same values again.
+         */
+        int[] memo = new int[n];
+
+        // Right pointer moves forward to expand the window
+        for (int right = 0; right < n; right++) {
+
+            // If current element is odd, increment odd count
+            if ((nums[right] & 1) == 1) {
+                oddCount++;
+            }
+
+            /*
+             * If oddCount exceeds k, shrink the window from the left
+             * until oddCount becomes valid again.
+             */
+            if (oddCount > k) {
+                left += memo[left];
+                oddCount--;
+            }
+
+            /*
+             * When the window contains exactly k odd numbers,
+             * count all possible valid subarrays starting at `left`.
+             */
+            if (oddCount == k) {
+
+                /*
+                 * If this left index hasn't been processed before,
+                 * count how many consecutive even numbers follow it.
+                 */
+                if (memo[left] == 0) {
+                    int count = 0;
+                    int temp = left;
+
+                    // Count consecutive even numbers
+                    while ((nums[temp] & 1) == 0) {
+                        count++;
+                        temp++;
+                    }
+
+                    /*
+                     * Number of valid subarrays starting at `left`
+                     * is (count of even numbers + 1)
+                     */
+                    memo[left] = count + 1;
+                }
+
+                // Add number of valid subarrays for this left position
+                result += memo[left];
+            }
+        }
+        return result;
+    }
+}

src/main/java/com/thealgorithms/sorts/TournamentSort.java

@@ -0,0 +1,84 @@
+package com.thealgorithms.sorts;
+
+import java.util.Arrays;
+
+/**
+ * Tournament Sort algorithm implementation.
+ *
+ * Tournament sort builds a winner tree (a complete binary tree storing the index
+ * of the smallest element in each subtree). It then repeatedly extracts the
+ * winner (minimum) and updates the path from the removed leaf to the root.
+ *
+ * Time Complexity:
+ * - Best case: O(n log n)
+ * - Average case: O(n log n)
+ * - Worst case: O(n log n)
+ *
+ * Space Complexity: O(n) – additional winner-tree storage
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Tournament_sort">Tournament Sort Algorithm</a>
+ * @see SortAlgorithm
+ */
+public class TournamentSort implements SortAlgorithm {
+
+    @Override
+    public <T extends Comparable<T>> T[] sort(T[] array) {
+        if (array == null || array.length < 2) {
+            return array;
+        }
+
+        final int n = array.length;
+        final int leafCount = nextPowerOfTwo(n);
+
+        // Winner tree represented as an array:
+        // - Leaves live at [leafCount .. 2*leafCount)
+        // - Internal nodes live at [1 .. leafCount)
+        // Each node stores an index into the original array or -1 for "empty".
+        final int[] tree = new int[2 * leafCount];
+        Arrays.fill(tree, -1);
+
+        for (int i = 0; i < n; i++) {
+            tree[leafCount + i] = i;
+        }
+
+        for (int node = leafCount - 1; node >= 1; node--) {
+            tree[node] = winnerIndex(array, tree[node * 2], tree[node * 2 + 1]);
+        }
+
+        final T[] result = array.clone();
+        for (int out = 0; out < n; out++) {
+            final int winner = tree[1];
+            result[out] = array[winner];
+
+            int node = leafCount + winner;
+            tree[node] = -1;
+
+            for (node /= 2; node >= 1; node /= 2) {
+                tree[node] = winnerIndex(array, tree[node * 2], tree[node * 2 + 1]);
+            }
+        }
+
+        System.arraycopy(result, 0, array, 0, n);
+        return array;
+    }
+
+    private static int nextPowerOfTwo(int n) {
+        int power = 1;
+        while (power < n) {
+            power <<= 1;
+        }
+        return power;
+    }
+
+    private static <T extends Comparable<T>> int winnerIndex(T[] array, int leftIndex, int rightIndex) {
+        if (leftIndex == -1) {
+            return rightIndex;
+        }
+        if (rightIndex == -1) {
+            return leftIndex;
+        }
+
+        // If equal, prefer the left element to keep ordering deterministic.
+        return SortUtils.less(array[rightIndex], array[leftIndex]) ? rightIndex : leftIndex;
+    }
+}

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

@@ -0,0 +1,53 @@
+package com.thealgorithms.searches;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+class RotatedBinarySearchTest {
+
+    @Test
+    void shouldFindElementInRotatedArrayLeftSide() {
+        RotatedBinarySearch search = new RotatedBinarySearch();
+        Integer[] array = {8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7};
+        assertEquals(2, search.find(array, 10));
+    }
+
+    @Test
+    void shouldFindElementInRotatedArrayRightSide() {
+        RotatedBinarySearch search = new RotatedBinarySearch();
+        Integer[] array = {8, 9, 10, 11, 12, 1, 2, 3, 4, 5, 6, 7};
+        assertEquals(6, search.find(array, 2));
+    }
+
+    @Test
+    void shouldFindElementInNotRotatedArray() {
+        RotatedBinarySearch search = new RotatedBinarySearch();
+        Integer[] array = {1, 2, 3, 4, 5, 6, 7};
+        assertEquals(4, search.find(array, 5));
+    }
+
+    @Test
+    void shouldReturnMinusOneWhenNotFound() {
+        RotatedBinarySearch search = new RotatedBinarySearch();
+        Integer[] array = {4, 5, 6, 7, 0, 1, 2};
+        assertEquals(-1, search.find(array, 3));
+    }
+
+    @Test
+    void shouldHandleWhenMiddleIsGreaterThanKeyInRightSortedHalf() {
+        RotatedBinarySearch search = new RotatedBinarySearch();
+        Integer[] array = {6, 7, 0, 1, 2, 3, 4, 5};
+        assertEquals(2, search.find(array, 0));
+    }
+
+    @Test
+    void shouldHandleDuplicates() {
+        RotatedBinarySearch search = new RotatedBinarySearch();
+        Integer[] array = {2, 2, 2, 3, 4, 2};
+        int index = search.find(array, 3);
+        assertTrue(index >= 0 && index < array.length);
+        assertEquals(3, array[index]);
+    }
+}

src/test/java/com/thealgorithms/slidingwindow/CountNiceSubarraysTest.java

@@ -0,0 +1,55 @@
+package com.thealgorithms.slidingwindow;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class CountNiceSubarraysTest {
+    @Test
+    void testExampleCase() {
+        int[] nums = {1, 1, 2, 1, 1};
+        assertEquals(2, CountNiceSubarrays.countNiceSubarrays(nums, 3));
+    }
+
+    @Test
+    void testAllEvenNumbers() {
+        int[] nums = {2, 4, 6, 8};
+        assertEquals(0, CountNiceSubarrays.countNiceSubarrays(nums, 1));
+    }
+
+    @Test
+    void testSingleOdd() {
+        int[] nums = {1};
+        assertEquals(1, CountNiceSubarrays.countNiceSubarrays(nums, 1));
+    }
+
+    @Test
+    void testMultipleChoices() {
+        int[] nums = {2, 2, 1, 2, 2, 1, 2};
+        assertEquals(6, CountNiceSubarrays.countNiceSubarrays(nums, 2));
+    }
+
+    @Test
+    void testTrailingEvenNumbers() {
+        int[] nums = {1, 2, 2, 2};
+        assertEquals(4, CountNiceSubarrays.countNiceSubarrays(nums, 1));
+    }
+
+    @Test
+    void testMultipleWindowShrinks() {
+        int[] nums = {1, 1, 1, 1};
+        assertEquals(3, CountNiceSubarrays.countNiceSubarrays(nums, 2));
+    }
+
+    @Test
+    void testEvensBetweenOdds() {
+        int[] nums = {2, 1, 2, 1, 2};
+        assertEquals(4, CountNiceSubarrays.countNiceSubarrays(nums, 2));
+    }
+
+    @Test
+    void testShrinkWithTrailingEvens() {
+        int[] nums = {2, 2, 1, 2, 2, 1, 2, 2};
+        assertEquals(9, CountNiceSubarrays.countNiceSubarrays(nums, 2));
+    }
+}