Merge branch 'master' into master

Author: gopaljilab

.github/workflows/close-failed-prs.yml

@@ -59,11 +59,13 @@ jobs:
 
                   const meaningfulCommits = commits.filter(c => {
                     const msg = c.commit.message.toLowerCase();
+                    const date = new Date(c.commit.committer.date);
                     const isMergeFromMain = mainBranches.some(branch =>
                       msg.startsWith(`merge branch '${branch}'`) ||
                       msg.includes(`merge remote-tracking branch '${branch}'`)
                     );
-                    return !isMergeFromMain;
+                      
+                    return !isMergeFromMain && date > cutoff;
                   });
 
                   // Get checks with error handling
@@ -151,4 +153,4 @@ jobs:
             } catch (error) {
               console.error(`❌ Fatal error: ${error.message}`);
               throw error;
-            }
+            }

DIRECTORY.md

@@ -112,7 +112,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>12.1.1</version>
+                    <version>12.1.2</version>
                     </dependency>
                 </dependencies>
             </plugin>
@@ -127,7 +127,7 @@
                         <plugin>
                             <groupId>com.mebigfatguy.fb-contrib</groupId>
                             <artifactId>fb-contrib</artifactId>
-                            <version>7.6.15</version>
+                            <version>7.7.0</version>
                         </plugin>
                         <plugin>
                             <groupId>com.h3xstream.findsecbugs</groupId>
@@ -155,4 +155,4 @@
             </plugin>
         </plugins>
     </build>
-</project>
+</project>

pom.xml

@@ -201,6 +201,12 @@
     <Match>
         <Bug pattern="SPP_FIELD_COULD_BE_STATIC" />
     </Match>
+    <Match>
+        <Bug pattern="ITC_INHERITANCE_TYPE_CHECKING" />
+    </Match>
+    <Match>
+        <Bug pattern="FII_USE_ARRAYS_STREAM" />
+    </Match>
     <!-- find-sec-bugs -->
     <Match>
         <Bug pattern="PREDICTABLE_RANDOM" />

spotbugs-exclude.xml

@@ -0,0 +1,48 @@
+package com.thealgorithms.backtracking;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/** Backtracking: pick/not-pick with reuse of candidates. */
+public final class CombinationSum {
+    private CombinationSum() {
+        throw new UnsupportedOperationException("Utility class");
+    }
+
+    public static List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> results = new ArrayList<>();
+        if (candidates == null || candidates.length == 0) {
+            return results;
+        }
+
+        // Sort to help with pruning duplicates and early termination
+        Arrays.sort(candidates);
+        backtrack(candidates, target, 0, new ArrayList<>(), results);
+        return results;
+    }
+
+    private static void backtrack(int[] candidates, int remaining, int start, List<Integer> combination, List<List<Integer>> results) {
+        if (remaining == 0) {
+            // Found valid combination; add a copy
+            results.add(new ArrayList<>(combination));
+            return;
+        }
+
+        for (int i = start; i < candidates.length; i++) {
+            int candidate = candidates[i];
+
+            // If candidate is greater than remaining target, further candidates (sorted) will also be too big
+            if (candidate > remaining) {
+                break;
+            }
+
+            // include candidate
+            combination.add(candidate);
+            // Because we can reuse the same element, we pass i (not i + 1)
+            backtrack(candidates, remaining - candidate, i, combination, results);
+            // backtrack: remove last
+            combination.remove(combination.size() - 1);
+        }
+    }
+}

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

@@ -12,8 +12,8 @@ private FloodFill() {
      * Get the color at the given coordinates of a 2D image
      *
      * @param image The image to be filled
-     * @param x The x co-ordinate of which color is to be obtained
-     * @param y The y co-ordinate of which color is to be obtained
+     * @param x The x coordinate of which color is to be obtained
+     * @param y The y coordinate of which color is to be obtained
      */
 
     public static int getPixel(final int[][] image, final int x, final int y) {
@@ -24,8 +24,8 @@ public static int getPixel(final int[][] image, final int x, final int y) {
      * Put the color at the given coordinates of a 2D image
      *
      * @param image The image to be filled
-     * @param x The x co-ordinate at which color is to be filled
-     * @param y The y co-ordinate at which color is to be filled
+     * @param x The x coordinate at which color is to be filled
+     * @param y The y coordinate at which color is to be filled
      */
     public static void putPixel(final int[][] image, final int x, final int y, final int newColor) {
         image[x][y] = newColor;
@@ -35,8 +35,8 @@ public static void putPixel(final int[][] image, final int x, final int y, final
      * Fill the 2D image with new color
      *
      * @param image The image to be filled
-     * @param x The x co-ordinate at which color is to be filled
-     * @param y The y co-ordinate at which color is to be filled
+     * @param x The x coordinate at which color is to be filled
+     * @param y The y coordinate at which color is to be filled
      * @param newColor The new color which to be filled in the image
      * @param oldColor The old color which is to be replaced in the image
      */

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

@@ -0,0 +1,83 @@
+package com.thealgorithms.bitmanipulation;
+
+/**
+ * Utility class for performing circular bit rotations on 32-bit integers.
+ * Bit rotation is a circular shift operation where bits shifted out on one end
+ * are reinserted on the opposite end.
+ *
+ * <p>This class provides methods for both left and right circular rotations,
+ * supporting only 32-bit integer operations with proper shift normalization
+ * and error handling.</p>
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Bit_rotation">Bit Rotation</a>
+ */
+public final class BitRotate {
+
+    /**
+     * Private constructor to prevent instantiation.
+     * This is a utility class with only static methods.
+     */
+    private BitRotate() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+
+    /**
+     * Performs a circular left rotation (left shift) on a 32-bit integer.
+     * Bits shifted out from the left side are inserted on the right side.
+     *
+     * @param value the 32-bit integer value to rotate
+     * @param shift the number of positions to rotate left (must be non-negative)
+     * @return the result of left rotating the value by the specified shift amount
+     * @throws IllegalArgumentException if shift is negative
+     *
+     * @example
+     * // Binary: 10000000 00000000 00000000 00000001
+     * rotateLeft(0x80000001, 1)
+     * // Returns: 3 (binary: 00000000 00000000 00000000 00000011)
+     */
+    public static int rotateLeft(int value, int shift) {
+        if (shift < 0) {
+            throw new IllegalArgumentException("Shift amount cannot be negative: " + shift);
+        }
+
+        // Normalize shift to the range [0, 31] using modulo 32
+        shift = shift % 32;
+
+        if (shift == 0) {
+            return value;
+        }
+
+        // Left rotation: (value << shift) | (value >>> (32 - shift))
+        return (value << shift) | (value >>> (32 - shift));
+    }
+
+    /**
+     * Performs a circular right rotation (right shift) on a 32-bit integer.
+     * Bits shifted out from the right side are inserted on the left side.
+     *
+     * @param value the 32-bit integer value to rotate
+     * @param shift the number of positions to rotate right (must be non-negative)
+     * @return the result of right rotating the value by the specified shift amount
+     * @throws IllegalArgumentException if shift is negative
+     *
+     * @example
+     * // Binary: 00000000 00000000 00000000 00000011
+     * rotateRight(3, 1)
+     * // Returns: -2147483647 (binary: 10000000 00000000 00000000 00000001)
+     */
+    public static int rotateRight(int value, int shift) {
+        if (shift < 0) {
+            throw new IllegalArgumentException("Shift amount cannot be negative: " + shift);
+        }
+
+        // Normalize shift to the range [0, 31] using modulo 32
+        shift = shift % 32;
+
+        if (shift == 0) {
+            return value;
+        }
+
+        // Right rotation: (value >>> shift) | (value << (32 - shift))
+        return (value >>> shift) | (value << (32 - shift));
+    }
+}

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

@@ -2738,7 +2738,7 @@ public static BigInteger decrypt(BigInteger cipherText, BigInteger key) {
 
     public static void main(String[] args) {
         try (Scanner input = new Scanner(System.in)) {
-            System.out.println("Enter (e) letter for encrpyt or (d) letter for decrypt :");
+            System.out.println("Enter (e) letter for encrypt or (d) letter for decrypt :");
             char choice = input.nextLine().charAt(0);
             String in;
             switch (choice) {

src/main/java/com/thealgorithms/ciphers/AES.java

@@ -16,7 +16,7 @@ private TurkishToLatinConversion() {
      * 2. Replace all turkish characters with their corresponding latin characters
      * 3. Return the converted string
      *
-     * @param param String paramter
+     * @param param String parameter
      * @return String
      */
     public static String convertTurkishToLatin(String param) {

src/main/java/com/thealgorithms/conversions/TurkishToLatinConversion.java

@@ -160,7 +160,7 @@ public void show(int source, int end,
                 break;
             }
         }
-        if (neg == 0) { // Go ahead and show results of computaion
+        if (neg == 0) { // Go ahead and show results of computation
             System.out.println("Distance is: " + dist[end]);
             System.out.println("Path followed:");
             System.out.print(source + " ");