Merge branch 'master' into master

Author: justanothercoder-hub

pom.xml

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

spotbugs-exclude.xml

@@ -207,6 +207,21 @@
     <Match>
         <Bug pattern="FII_USE_ARRAYS_STREAM" />
     </Match>
+    <Match>
+        <Bug pattern="UTAO_JUNIT_ASSERTION_ODDITIES_USE_ASSERT_EQUALS" />
+    </Match>
+    <Match>
+        <Bug pattern="UTAO_JUNIT_ASSERTION_ODDITIES_USE_ASSERT_NOT_EQUALS" />
+    </Match>
+    <Match>
+        <Bug pattern="UTAO_JUNIT_ASSERTION_ODDITIES_ACTUAL_CONSTANT" />
+    </Match>
+    <Match>
+        <Bug pattern="UTAO_JUNIT_ASSERTION_ODDITIES_INEXACT_DOUBLE" />
+    </Match>
+    <Match>
+        <Bug pattern="UTAO_JUNIT_ASSERTION_ODDITIES_IMPOSSIBLE_NULL" />
+    </Match>
     <!-- find-sec-bugs -->
     <Match>
         <Bug pattern="PREDICTABLE_RANDOM" />

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

@@ -0,0 +1,59 @@
+package com.thealgorithms.maths;
+
+/**
+ * The Bell numbers count the number of partitions of a set.
+ * The n-th Bell number is the number of ways a set of n elements can be partitioned
+ * into nonempty subsets.
+ *
+ * <p>
+ * This implementation uses the Bell Triangle (Aitken's array) method.
+ * Time Complexity: O(n^2)
+ * Space Complexity: O(n^2)
+ * </p>
+ *
+ * @author Chahat Sandhu, <a href="https://github.com/singhc7">singhc7</a>
+ * @see <a href="https://en.wikipedia.org/wiki/Bell_number">Bell Number (Wikipedia)</a>
+ */
+public final class BellNumbers {
+
+    private BellNumbers() {
+    }
+
+    /**
+     * Calculates the n-th Bell number using the Bell Triangle.
+     *
+     * @param n the index of the Bell number (must be non-negative)
+     * @return the n-th Bell number
+     * @throws IllegalArgumentException if n is negative or n > 25
+     */
+    public static long compute(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("n must be non-negative");
+        }
+        if (n == 0) {
+            return 1;
+        }
+        if (n > 25) {
+            throw new IllegalArgumentException("n must be <= 25. For larger n, use BigInteger implementation.");
+        }
+
+        // We use a 2D array to visualize the Bell Triangle
+        long[][] bellTriangle = new long[n + 1][n + 1];
+
+        // Base case: The triangle starts with 1
+        bellTriangle[0][0] = 1;
+
+        for (int i = 1; i <= n; i++) {
+            // Rule 1: The first number in a new row is the LAST number of the previous row
+            bellTriangle[i][0] = bellTriangle[i - 1][i - 1];
+
+            // Rule 2: Fill the rest of the row by adding the previous neighbor and the upper-left neighbor
+            for (int j = 1; j <= i; j++) {
+                bellTriangle[i][j] = bellTriangle[i][j - 1] + bellTriangle[i - 1][j - 1];
+            }
+        }
+
+        // The Bell number B_n is the first number in the n-th row
+        return bellTriangle[n][0];
+    }
+}

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

@@ -0,0 +1,33 @@
+package com.thealgorithms.maths;
+
+/**
+ * Distance Between Two Points in 2D Space.
+ *
+ * <p>This class provides a method to calculate the Euclidean distance between two points in a
+ * two-dimensional plane.
+ *
+ * <p>Formula: d = sqrt((x2 - x1)^2 + (y2 - y1)^2)
+ *
+ * <p>Reference: https://en.wikipedia.org/wiki/Euclidean_distance
+ */
+public final class DistanceBetweenTwoPoints {
+
+    private DistanceBetweenTwoPoints() {
+        // Utility class; prevent instantiation
+    }
+
+    /**
+     * Calculate the Euclidean distance between two points.
+     *
+     * @param x1 x-coordinate of the first point
+     * @param y1 y-coordinate of the first point
+     * @param x2 x-coordinate of the second point
+     * @param y2 y-coordinate of the second point
+     * @return Euclidean distance between the two points
+     */
+    public static double calculate(final double x1, final double y1, final double x2, final double y2) {
+        final double deltaX = x2 - x1;
+        final double deltaY = y2 - y1;
+        return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+    }
+}

src/main/java/com/thealgorithms/prefixsum/PrefixSum.java

@@ -0,0 +1,54 @@
+package com.thealgorithms.prefixsum;
+
+/**
+ * A class that implements the Prefix Sum algorithm.
+ *
+ * <p>Prefix Sum is a technique used to preprocess an array such that
+ * range sum queries can be answered in O(1) time.
+ * The preprocessing step takes O(N) time.
+ *
+ * <p>This implementation uses a long array for the prefix sums to prevent
+ * integer overflow when the sum of elements exceeds Integer.MAX_VALUE.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Prefix_sum">Prefix Sum (Wikipedia)</a>
+ * @author Chahat Sandhu, <a href="https://github.com/singhc7">singhc7</a>
+ */
+public class PrefixSum {
+
+    private final long[] prefixSums;
+
+    /**
+     * Constructor to preprocess the input array.
+     *
+     * @param array The input integer array.
+     * @throws IllegalArgumentException if the array is null.
+     */
+    public PrefixSum(int[] array) {
+        if (array == null) {
+            throw new IllegalArgumentException("Input array cannot be null");
+        }
+        this.prefixSums = new long[array.length + 1];
+        this.prefixSums[0] = 0;
+
+        for (int i = 0; i < array.length; i++) {
+            // Automatically promotes int to long during addition
+            this.prefixSums[i + 1] = this.prefixSums[i] + array[i];
+        }
+    }
+
+    /**
+     * Calculates the sum of elements in the range [left, right].
+     * Indices are 0-based.
+     *
+     * @param left  The starting index (inclusive).
+     * @param right The ending index (inclusive).
+     * @return The sum of elements from index left to right as a long.
+     * @throws IndexOutOfBoundsException if indices are out of valid range.
+     */
+    public long sumRange(int left, int right) {
+        if (left < 0 || right >= prefixSums.length - 1 || left > right) {
+            throw new IndexOutOfBoundsException("Invalid range indices");
+        }
+        return prefixSums[right + 1] - prefixSums[left];
+    }
+}

src/main/java/com/thealgorithms/prefixsum/PrefixSum2D.java

@@ -0,0 +1,64 @@
+package com.thealgorithms.prefixsum;
+
+/**
+ * A class that implements the 2D Prefix Sum algorithm.
+ *
+ * <p>2D Prefix Sum is a technique used to preprocess a 2D matrix such that
+ * sub-matrix sum queries can be answered in O(1) time.
+ * The preprocessing step takes O(N*M) time.
+ *
+ * <p>This implementation uses a long array for the prefix sums to prevent
+ * integer overflow.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Summed-area_table">Summed-area table (Wikipedia)</a>
+ * @author Chahat Sandhu, <a href="https://github.com/singhc7">singhc7</a>
+ */
+public class PrefixSum2D {
+
+    private final long[][] prefixSums;
+
+    /**
+     * Constructor to preprocess the input matrix.
+     *
+     * @param matrix The input integer matrix.
+     * @throws IllegalArgumentException if the matrix is null or empty.
+     */
+    public PrefixSum2D(int[][] matrix) {
+        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
+            throw new IllegalArgumentException("Input matrix cannot be null or empty");
+        }
+
+        int rows = matrix.length;
+        int cols = matrix[0].length;
+        this.prefixSums = new long[rows + 1][cols + 1];
+
+        for (int i = 0; i < rows; i++) {
+            for (int j = 0; j < cols; j++) {
+                // P[i+1][j+1] = current + above + left - diagonal_overlap
+                this.prefixSums[i + 1][j + 1] = matrix[i][j] + this.prefixSums[i][j + 1] + this.prefixSums[i + 1][j] - this.prefixSums[i][j];
+            }
+        }
+    }
+
+    /**
+     * Calculates the sum of the sub-matrix defined by (row1, col1) to (row2, col2).
+     * Indices are 0-based.
+     *
+     * @param row1 Top row index.
+     * @param col1 Left column index.
+     * @param row2 Bottom row index.
+     * @param col2 Right column index.
+     * @return The sum of the sub-matrix.
+     * @throws IndexOutOfBoundsException if indices are invalid.
+     */
+    public long sumRegion(int row1, int col1, int row2, int col2) {
+        if (row1 < 0 || row2 >= prefixSums.length - 1 || row2 < row1) {
+            throw new IndexOutOfBoundsException("Invalid row indices");
+        }
+        if (col1 < 0 || col2 >= prefixSums[0].length - 1 || col2 < col1) {
+            throw new IndexOutOfBoundsException("Invalid column indices");
+        }
+
+        return prefixSums[row2 + 1][col2 + 1] - prefixSums[row1][col2 + 1] - prefixSums[row2 + 1][col1] + prefixSums[row1][col1];
+    }
+}

src/test/java/com/thealgorithms/ciphers/PermutationCipherTest.java

@@ -1,6 +1,7 @@
 package com.thealgorithms.ciphers;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.junit.jupiter.api.Test;
@@ -121,8 +122,8 @@ void testNullString() {
         String decrypted = cipher.decrypt(encrypted, key);
 
         // then
-        assertEquals(null, encrypted);
-        assertEquals(null, decrypted);
+        assertNull(encrypted);
+        assertNull(decrypted);
     }
 
     @Test

src/test/java/com/thealgorithms/datastructures/heaps/HeapElementTest.java

@@ -2,6 +2,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
 import org.junit.jupiter.api.Test;
@@ -39,7 +40,7 @@ void testEquals() {
 
         assertEquals(element1, element2); // Same key and info
         assertNotEquals(element1, element3); // Different key
-        assertNotEquals(null, element1); // Check for null
+        assertNotNull(element1);
         assertNotEquals("String", element1); // Check for different type
     }
 

src/test/java/com/thealgorithms/datastructures/trees/TreapTest.java

@@ -2,6 +2,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 import org.junit.jupiter.api.Test;
 
@@ -30,7 +31,7 @@ public void searchAndNotFound() {
         treap.insert(3);
         treap.insert(8);
         treap.insert(1);
-        assertEquals(null, treap.search(4));
+        assertNull(treap.search(4));
     }
 
     @Test

src/test/java/com/thealgorithms/dynamicprogramming/LongestCommonSubsequenceTest.java

@@ -1,6 +1,7 @@
 package com.thealgorithms.dynamicprogramming;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 
 import org.junit.jupiter.api.Test;
 
@@ -55,27 +56,24 @@ public void testLCSWithBothEmptyStrings() {
     public void testLCSWithNullFirstString() {
         String str1 = null;
         String str2 = "XYZ";
-        String expected = null; // Should return null if first string is null
         String result = LongestCommonSubsequence.getLCS(str1, str2);
-        assertEquals(expected, result);
+        assertNull(result);
     }
 
     @Test
     public void testLCSWithNullSecondString() {
         String str1 = "ABC";
         String str2 = null;
-        String expected = null; // Should return null if second string is null
         String result = LongestCommonSubsequence.getLCS(str1, str2);
-        assertEquals(expected, result);
+        assertNull(result);
     }
 
     @Test
     public void testLCSWithNullBothStrings() {
         String str1 = null;
         String str2 = null;
-        String expected = null; // Should return null if both strings are null
         String result = LongestCommonSubsequence.getLCS(str1, str2);
-        assertEquals(expected, result);
+        assertNull(result);
     }
 
     @Test