Merge remote-tracking branch 'origin/speculative_new_algo' into speculative_new_algo

Author: Hardvan

DIRECTORY.md

@@ -20,7 +20,7 @@
             <dependency>
                 <groupId>org.junit</groupId>
                 <artifactId>junit-bom</artifactId>
-                <version>5.11.2</version>
+                <version>5.11.3</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -31,7 +31,7 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
-            <version>5.11.2</version>
+            <version>5.11.3</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -43,15 +43,15 @@
         <dependency>
             <groupId>org.mockito</groupId>
             <artifactId>mockito-core</artifactId>
-            <version>5.14.1</version>
+            <version>5.14.2</version>
             <scope>test</scope>
         </dependency>
 
 
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-api</artifactId>
-            <version>5.11.2</version>
+            <version>5.11.3</version>
             <scope>test</scope>
         </dependency>
         <dependency>
@@ -114,7 +114,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-checkstyle-plugin</artifactId>
-                <version>3.5.0</version>
+                <version>3.6.0</version>
                 <configuration>
                     <configLocation>checkstyle.xml</configLocation>
                     <consoleOutput>true</consoleOutput>
@@ -132,7 +132,7 @@
             <plugin>
                 <groupId>com.github.spotbugs</groupId>
                 <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.8.6.4</version>
+                <version>4.8.6.5</version>
                 <configuration>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                     <includeTests>true</includeTests>

pom.xml

@@ -87,9 +87,6 @@
         <Bug pattern="RCN_REDUNDANT_NULLCHECK_OF_NONNULL_VALUE" />
     </Match>
     <!-- fb-contrib -->
-    <Match>
-        <Bug pattern="OCP_OVERLY_CONCRETE_PARAMETER" />
-    </Match>
     <Match>
         <Bug pattern="LSC_LITERAL_STRING_COMPARISON" />
     </Match>

spotbugs-exclude.xml

@@ -4,32 +4,44 @@
 import java.util.List;
 
 /**
- * Finds all combinations of 0...n-1 of length k
+ * This class provides methods to find all combinations of integers from 0 to n-1
+ * of a specified length k using backtracking.
  */
 public final class ArrayCombination {
     private ArrayCombination() {
     }
 
     /**
-     * Finds all combinations of length k of 0..n-1 using backtracking.
+     * Generates all possible combinations of length k from the integers 0 to n-1.
      *
-     * @param n Number of the elements.
-     * @param k Length of the combination.
-     * @return A list of all combinations of length k.
+     * @param n The total number of elements (0 to n-1).
+     * @param k The desired length of each combination.
+     * @return A list containing all combinations of length k.
+     * @throws IllegalArgumentException if n or k are negative, or if k is greater than n.
      */
     public static List<List<Integer>> combination(int n, int k) {
         if (n < 0 || k < 0 || k > n) {
-            throw new IllegalArgumentException("Wrong input.");
+            throw new IllegalArgumentException("Invalid input: n must be non-negative, k must be non-negative and less than or equal to n.");
         }
 
         List<List<Integer>> combinations = new ArrayList<>();
         combine(combinations, new ArrayList<>(), 0, n, k);
         return combinations;
     }
 
+    /**
+     * A helper method that uses backtracking to find combinations.
+     *
+     * @param combinations The list to store all valid combinations found.
+     * @param current The current combination being built.
+     * @param start The starting index for the current recursion.
+     * @param n The total number of elements (0 to n-1).
+     * @param k The desired length of each combination.
+     */
     private static void combine(List<List<Integer>> combinations, List<Integer> current, int start, int n, int k) {
-        if (current.size() == k) { // Base case: combination found
-            combinations.add(new ArrayList<>(current)); // Copy to avoid modification
+        // Base case: combination found
+        if (current.size() == k) {
+            combinations.add(new ArrayList<>(current));
             return;
         }
 

src/main/java/com/thealgorithms/backtracking/ArrayCombination.java

@@ -1,6 +1,7 @@
 package com.thealgorithms.backtracking;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.TreeSet;
@@ -13,8 +14,6 @@ public final class Combination {
     private Combination() {
     }
 
-    private static int length;
-
     /**
      * Find all combinations of given array using backtracking
      * @param arr the array.
@@ -23,39 +22,45 @@ private Combination() {
      * @return a list of all combinations of length n. If n == 0, return null.
      */
     public static <T> List<TreeSet<T>> combination(T[] arr, int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("The combination length cannot be negative.");
+        }
+
         if (n == 0) {
-            return null;
+            return Collections.emptyList();
         }
-        length = n;
         T[] array = arr.clone();
         Arrays.sort(array);
+
         List<TreeSet<T>> result = new LinkedList<>();
-        backtracking(array, 0, new TreeSet<T>(), result);
+        backtracking(array, n, 0, new TreeSet<T>(), result);
         return result;
     }
 
     /**
      * Backtrack all possible combinations of a given array
      * @param arr the array.
+     * @param n length of the combination
      * @param index the starting index.
      * @param currSet set that tracks current combination
      * @param result the list contains all combination.
      * @param <T> the type of elements in the array.
      */
-    private static <T> void backtracking(T[] arr, int index, TreeSet<T> currSet, List<TreeSet<T>> result) {
-        if (index + length - currSet.size() > arr.length) {
+    private static <T> void backtracking(T[] arr, int n, int index, TreeSet<T> currSet, List<TreeSet<T>> result) {
+        if (index + n - currSet.size() > arr.length) {
             return;
         }
-        if (length - 1 == currSet.size()) {
+        if (currSet.size() == n - 1) {
             for (int i = index; i < arr.length; i++) {
                 currSet.add(arr[i]);
-                result.add((TreeSet<T>) currSet.clone());
+                result.add(new TreeSet<>(currSet));
                 currSet.remove(arr[i]);
             }
+            return;
         }
         for (int i = index; i < arr.length; i++) {
             currSet.add(arr[i]);
-            backtracking(arr, i + 1, currSet, result);
+            backtracking(arr, n, i + 1, currSet, result);
             currSet.remove(arr[i]);
         }
     }

src/main/java/com/thealgorithms/backtracking/Combination.java

@@ -1,6 +1,7 @@
 package com.thealgorithms.backtracking;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 
 /**
@@ -95,7 +96,7 @@ public static void removeWord(char[][] puzzle, String word, int row, int col, bo
      * @param words  The list of words to be placed.
      * @return true if the crossword is solved, false otherwise.
      */
-    public static boolean solveCrossword(char[][] puzzle, List<String> words) {
+    public static boolean solveCrossword(char[][] puzzle, Collection<String> words) {
         // Create a mutable copy of the words list
         List<String> remainingWords = new ArrayList<>(words);
 

src/main/java/com/thealgorithms/backtracking/CrosswordSolver.java

@@ -0,0 +1,33 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * This class provides a method to find the first differing bit
+ * between two integers.
+ *
+ * Example:
+ *  x = 10 (1010 in binary)
+ *  y = 12 (1100 in binary)
+ *  The first differing bit is at index 1 (0-based)
+ *  So, the output will be 1
+ *
+ * @author Hardvan
+ */
+public final class FirstDifferentBit {
+    private FirstDifferentBit() {
+    }
+
+    /**
+     * Identifies the index of the first differing bit between two integers.
+     * Steps:
+     * 1. XOR the two integers to get the differing bits
+     * 2. Find the index of the first set bit in XOR result
+     *
+     * @param x the first integer
+     * @param y the second integer
+     * @return the index of the first differing bit (0-based)
+     */
+    public static int firstDifferentBit(int x, int y) {
+        int diff = x ^ y;
+        return Integer.numberOfTrailingZeros(diff);
+    }
+}

src/main/java/com/thealgorithms/bitmanipulation/FirstDifferentBit.java

@@ -0,0 +1,44 @@
+package com.thealgorithms.bitmanipulation;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This class provides a method to generate all subsets (power set)
+ * of a given set using bit manipulation.
+ *
+ * @author Hardvan
+ */
+public final class GenerateSubsets {
+    private GenerateSubsets() {
+    }
+
+    /**
+     * Generates all subsets of a given set using bit manipulation.
+     * Steps:
+     * 1. Iterate over all numbers from 0 to 2^n - 1.
+     * 2. For each number, iterate over all bits from 0 to n - 1.
+     * 3. If the i-th bit of the number is set, add the i-th element of the set to the current subset.
+     * 4. Add the current subset to the list of subsets.
+     * 5. Return the list of subsets.
+     *
+     * @param set the input set of integers
+     * @return a list of all subsets represented as lists of integers
+     */
+    public static List<List<Integer>> generateSubsets(int[] set) {
+        int n = set.length;
+        List<List<Integer>> subsets = new ArrayList<>();
+
+        for (int mask = 0; mask < (1 << n); mask++) {
+            List<Integer> subset = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                if ((mask & (1 << i)) != 0) {
+                    subset.add(set[i]);
+                }
+            }
+            subsets.add(subset);
+        }
+
+        return subsets;
+    }
+}

src/main/java/com/thealgorithms/bitmanipulation/GenerateSubsets.java

@@ -1,13 +1,27 @@
 package com.thealgorithms.bitmanipulation;
 
 /**
- * Is number power of 2
+ * Utility class for checking if a number is a power of two.
+ * A power of two is a number that can be expressed as 2^n where n is a non-negative integer.
+ * This class provides a method to determine if a given integer is a power of two using bit manipulation.
+ *
  * @author Bama Charan Chhandogi (https://github.com/BamaCharanChhandogi)
  */
-
 public final class IsPowerTwo {
     private IsPowerTwo() {
     }
+
+    /**
+     * Checks if the given integer is a power of two.
+     *
+     * A number is considered a power of two if it is greater than zero and
+     * has exactly one '1' bit in its binary representation. This method
+     * uses the property that for any power of two (n), the expression
+     * (n & (n - 1)) will be zero.
+     *
+     * @param number the integer to check
+     * @return true if the number is a power of two, false otherwise
+     */
     public static boolean isPowerTwo(int number) {
         if (number <= 0) {
             return false;

src/main/java/com/thealgorithms/bitmanipulation/IsPowerTwo.java

@@ -0,0 +1,28 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * This class provides a method to compute the remainder
+ * of a number when divided by a power of two (2^n)
+ * without using division or modulo operations.
+ *
+ * @author Hardvan
+ */
+public final class ModuloPowerOfTwo {
+    private ModuloPowerOfTwo() {
+    }
+
+    /**
+     * Computes the remainder of a given integer when divided by 2^n.
+     *
+     * @param x the input number
+     * @param n the exponent (power of two)
+     * @return the remainder of x divided by 2^n
+     */
+    public static int moduloPowerOfTwo(int x, int n) {
+        if (n <= 0) {
+            throw new IllegalArgumentException("The exponent must be positive");
+        }
+
+        return x & ((1 << n) - 1);
+    }
+}

src/main/java/com/thealgorithms/bitmanipulation/ModuloPowerOfTwo.java

@@ -0,0 +1,30 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * This class provides a method to find the next higher number
+ * with the same number of set bits as the given number.
+ *
+ * @author Hardvan
+ */
+public final class NextHigherSameBitCount {
+    private NextHigherSameBitCount() {
+    }
+
+    /**
+     * Finds the next higher integer with the same number of set bits.
+     * Steps:
+     * 1. Find {@code c}, the rightmost set bit of {@code n}.
+     * 2. Find {@code r}, the rightmost set bit of {@code n + c}.
+     * 3. Swap the bits of {@code r} and {@code n} to the right of {@code c}.
+     * 4. Shift the bits of {@code r} and {@code n} to the right of {@code c} to the rightmost.
+     * 5. Combine the results of steps 3 and 4.
+     *
+     * @param n the input number
+     * @return the next higher integer with the same set bit count
+     */
+    public static int nextHigherSameBitCount(int n) {
+        int c = n & -n;
+        int r = n + c;
+        return (((r ^ n) >> 2) / c) | r;
+    }
+}