Merge branch 'master' into add-multinomial-naive-bayes

Author: DenizAltunkapan

.github/workflows/build.yml

@@ -10,7 +10,7 @@ jobs:
     steps:
       - uses: actions/checkout@v7
       - name: Set up JDK
-        uses: actions/setup-java@v5.5.0
+        uses: actions/setup-java@v5.6.0
         with:
           java-version: 21
           distribution: 'temurin'

.github/workflows/codeql.yml

@@ -24,21 +24,21 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Set up JDK
-        uses: actions/setup-java@v5.5.0
+        uses: actions/setup-java@v5.6.0
         with:
           java-version: 21
           distribution: 'temurin'
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4.37.0
+        uses: github/codeql-action/init@v4.37.3
         with:
           languages: 'java-kotlin'
 
       - name: Build
         run: mvn --batch-mode --update-snapshots verify
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4.37.0
+        uses: github/codeql-action/analyze@v4.37.3
         with:
           category: "/language:java-kotlin"
 
@@ -55,12 +55,12 @@ jobs:
         uses: actions/checkout@v7
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v4.37.0
+        uses: github/codeql-action/init@v4.37.3
         with:
           languages: 'actions'
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v4.37.0
+        uses: github/codeql-action/analyze@v4.37.3
         with:
           category: "/language:actions"
 ...

.github/workflows/infer.yml

@@ -18,7 +18,7 @@ jobs:
       - uses: actions/checkout@v7
 
       - name: Set up JDK
-        uses: actions/setup-java@v5.5.0
+        uses: actions/setup-java@v5.6.0
         with:
           java-version: 21
           distribution: 'temurin'

.github/workflows/project_structure.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v7
-      - uses: actions/setup-python@v6.3.0
+      - uses: actions/setup-python@v7.0.0
         with:
           python-version: '3.13'
 

pom.xml

@@ -119,7 +119,7 @@
             <plugin>
                 <groupId>com.github.spotbugs</groupId>
                 <artifactId>spotbugs-maven-plugin</artifactId>
-                <version>4.10.2.0</version>
+                <version>4.10.3.0</version>
                 <configuration>
                     <excludeFilterFile>spotbugs-exclude.xml</excludeFilterFile>
                     <includeTests>true</includeTests>

spotbugs-exclude.xml

@@ -59,6 +59,12 @@
     <Match>
         <Bug pattern="AT_STALE_THREAD_WRITE_OF_PRIMITIVE" />
     </Match>
+    <Match>
+        <Bug pattern="NP_NULL_PARAM_DEREF_NONVIRTUAL" />
+    </Match>
+    <Match>
+        <Bug pattern="NP_NULL_PARAM_DEREF_ALL_TARGETS_DANGEROUS" />
+    </Match>
     <!-- fb-contrib -->
     <Match>
         <Bug pattern="LSC_LITERAL_STRING_COMPARISON" />

src/main/java/com/thealgorithms/datastructures/graphs/RottingOranges.java

@@ -0,0 +1,114 @@
+package com.thealgorithms.datastructures.graphs;
+
+import java.util.LinkedList;
+import java.util.Queue;
+
+/**
+ * Multi-source Breadth-First Search (BFS) implementation for the Rotting Oranges problem.
+ *
+ * <p>Algorithm explanation:
+ * https://en.wikipedia.org/wiki/Breadth-first_search
+ *
+ * <p>Problem reference:
+ * https://leetcode.com/problems/rotting-oranges/
+ *
+ * <p>Given a grid where:
+ * <ul>
+ *     <li>0 represents an empty cell</li>
+ *     <li>1 represents a fresh orange</li>
+ *     <li>2 represents a rotten orange</li>
+ * </ul>
+ *
+ * <p>Returns the minimum number of minutes required for all fresh oranges
+ * to become rotten. Returns {@code -1} if it is impossible.
+ *
+ * <p>Time Complexity: O(m × n)
+ * <br>Space Complexity: O(m × n)
+ */
+public class RottingOranges {
+
+    private static final int[] DEL_ROW = {-1, 0, 1, 0};
+    private static final int[] DEL_COL = {0, 1, 0, -1};
+
+    private static final class Cell {
+        private final int row;
+        private final int col;
+        private final int minute;
+
+        Cell(int row, int col, int minute) {
+            this.row = row;
+            this.col = col;
+            this.minute = minute;
+        }
+    }
+
+    /**
+     * Executes the Rotting Oranges algorithm.
+     *
+     * @param grid the input grid
+     * @return minimum minutes required to rot all fresh oranges,
+     *         or -1 if impossible
+     */
+    public int run(int[][] grid) {
+
+        if (grid == null || grid.length == 0 || grid[0].length == 0) {
+            return 0;
+        }
+
+        int rows = grid.length;
+        int cols = grid[0].length;
+
+        // Create a copy so original input is not modified
+        int[][] copy = new int[rows][cols];
+
+        for (int i = 0; i < rows; i++) {
+            copy[i] = grid[i].clone();
+        }
+
+        Queue<Cell> queue = new LinkedList<>();
+        int freshOranges = 0;
+
+        // Find all rotten oranges and count fresh oranges
+        for (int row = 0; row < rows; row++) {
+            for (int col = 0; col < cols; col++) {
+
+                if (copy[row][col] == 2) {
+                    queue.offer(new Cell(row, col, 0));
+                } else if (copy[row][col] == 1) {
+                    freshOranges++;
+                }
+            }
+        }
+
+        if (freshOranges == 0) {
+            return 0;
+        }
+
+        int rottedFresh = 0;
+        int minutes = 0;
+
+        // Multi-source BFS
+        while (!queue.isEmpty()) {
+
+            Cell current = queue.poll();
+
+            minutes = Math.max(minutes, current.minute);
+
+            for (int i = 0; i < 4; i++) {
+
+                int newRow = current.row + DEL_ROW[i];
+                int newCol = current.col + DEL_COL[i];
+
+                if (newRow >= 0 && newRow < rows && newCol >= 0 && newCol < cols && copy[newRow][newCol] == 1) {
+
+                    copy[newRow][newCol] = 2;
+                    rottedFresh++;
+
+                    queue.offer(new Cell(newRow, newCol, current.minute + 1));
+                }
+            }
+        }
+
+        return rottedFresh == freshOranges ? minutes : -1;
+    }
+}

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

@@ -1,7 +1,5 @@
 package com.thealgorithms.maths;
 
-import java.util.Arrays;
-
 public final class AbsoluteMin {
     private AbsoluteMin() {
     }
@@ -13,14 +11,17 @@ private AbsoluteMin() {
      * @return The absolute min value
      */
     public static int getMinValue(int... numbers) {
-        if (numbers.length == 0) {
-            throw new IllegalArgumentException("Numbers array cannot be empty");
+        if (numbers == null || numbers.length == 0) {
+            throw new IllegalArgumentException("Numbers array cannot be empty or null");
         }
 
-        var absMinWrapper = new Object() { int value = numbers[0]; };
-
-        Arrays.stream(numbers).skip(1).filter(number -> Math.abs(number) <= Math.abs(absMinWrapper.value)).forEach(number -> absMinWrapper.value = Math.min(absMinWrapper.value, number));
-
-        return absMinWrapper.value;
+        long absMin = numbers[0];
+        for (int i = 1; i < numbers.length; i++) {
+            long current = numbers[i];
+            if (Math.abs(current) < Math.abs(absMin) || (Math.abs(current) == Math.abs(absMin) && current < absMin)) {
+                absMin = current;
+            }
+        }
+        return (int) absMin;
     }
 }

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

@@ -5,7 +5,6 @@
  * Find minimum number of perfect squares that sum to given number
  *
  * @see <a href="https://en.wikipedia.org/wiki/Lagrange%27s_four-square_theorem">Lagrange's Four Square Theorem</a>
- * @author BEASTSHRIRAM
  */
 public final class SumOfSquares {
 
@@ -16,10 +15,15 @@ private SumOfSquares() {
     /**
      * Find minimum number of perfect squares that sum to n
      *
-     * @param n the target number
+     * @param n the target number (must be non-negative)
      * @return minimum number of squares needed
+     * @throws IllegalArgumentException if n is negative
      */
     public static int minSquares(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative");
+        }
+
         if (isPerfectSquare(n)) {
             return 1;
         }

src/test/java/com/thealgorithms/datastructures/graphs/RottingOrangesTest.java

@@ -0,0 +1,134 @@
+package com.thealgorithms.datastructures.graphs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class RottingOrangesTest {
+
+    @Test
+    void testAllOrangesRotInSingleMinute() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2, 1, 1}, {1, 1, 0}, {0, 1, 1}};
+
+        assertEquals(4, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testImpossibleToRotAllOranges() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2, 1, 1}, {0, 1, 1}, {1, 0, 1}};
+
+        assertEquals(-1, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testNoFreshOranges() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2, 2}, {2, 2}};
+
+        assertEquals(0, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testNoRottenOranges() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{1, 1}, {1, 1}};
+
+        assertEquals(-1, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testEmptyGrid() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {};
+
+        assertEquals(0, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testSingleRottenOrange() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2}};
+
+        assertEquals(0, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testSingleFreshOrange() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{1}};
+
+        assertEquals(-1, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testSingleFreshOrangeNextToRottenOrange() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2, 1}};
+
+        assertEquals(1, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testMultipleRottenSources() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2, 1, 0, 2}, {1, 1, 1, 1}, {0, 1, 1, 1}};
+
+        assertEquals(3, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testFreshOrangeBlockedByEmptyCells() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2, 0, 1}, {0, 0, 0}, {1, 0, 1}};
+
+        assertEquals(-1, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testLinearSpread() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2, 1, 1, 1, 1}};
+
+        assertEquals(4, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testVerticalSpread() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2}, {1}, {1}, {1}};
+
+        assertEquals(3, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testGridWithOnlyEmptyCells() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{0, 0}, {0, 0}};
+
+        assertEquals(0, rottingOranges.run(grid));
+    }
+
+    @Test
+    void testComplexGrid() {
+        RottingOranges rottingOranges = new RottingOranges();
+
+        int[][] grid = {{2, 1, 1}, {1, 1, 1}, {1, 1, 1}};
+
+        assertEquals(4, rottingOranges.run(grid));
+    }
+}