Merge branch 'master' into eulerpseudoprime

Author: alxkm

pom.xml

@@ -71,8 +71,7 @@
                 <artifactId>maven-compiler-plugin</artifactId>
                 <version>3.14.1</version>
                 <configuration>
-                    <source>21</source>
-                    <target>21</target>
+                    <release>21</release>
                     <compilerArgs>
                         <arg>-Xlint:all</arg>
                         <arg>-Xlint:-auxiliaryclass</arg>

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

@@ -0,0 +1,57 @@
+package com.thealgorithms.conversions;
+
+/**
+ * A utility class to convert between Cartesian and Polar coordinate systems.
+ *
+ * <p>This class provides methods to perform the following conversions:
+ * <ul>
+ *   <li>Cartesian to Polar coordinates</li>
+ *   <li>Polar to Cartesian coordinates</li>
+ * </ul>
+ *
+ * <p>The class is final and cannot be instantiated.
+ */
+public final class CoordinateConverter {
+
+    private CoordinateConverter() {
+        // Prevent instantiation
+    }
+
+    /**
+     * Converts Cartesian coordinates to Polar coordinates.
+     *
+     * @param x the x-coordinate in the Cartesian system; must be a finite number
+     * @param y the y-coordinate in the Cartesian system; must be a finite number
+     * @return an array where the first element is the radius (r) and the second element is the angle (theta) in degrees
+     * @throws IllegalArgumentException if x or y is not a finite number
+     */
+    public static double[] cartesianToPolar(double x, double y) {
+        if (!Double.isFinite(x) || !Double.isFinite(y)) {
+            throw new IllegalArgumentException("x and y must be finite numbers.");
+        }
+        double r = Math.sqrt(x * x + y * y);
+        double theta = Math.toDegrees(Math.atan2(y, x));
+        return new double[] {r, theta};
+    }
+
+    /**
+     * Converts Polar coordinates to Cartesian coordinates.
+     *
+     * @param r the radius in the Polar system; must be non-negative
+     * @param thetaDegrees the angle (theta) in degrees in the Polar system; must be a finite number
+     * @return an array where the first element is the x-coordinate and the second element is the y-coordinate in the Cartesian system
+     * @throws IllegalArgumentException if r is negative or thetaDegrees is not a finite number
+     */
+    public static double[] polarToCartesian(double r, double thetaDegrees) {
+        if (r < 0) {
+            throw new IllegalArgumentException("Radius (r) must be non-negative.");
+        }
+        if (!Double.isFinite(thetaDegrees)) {
+            throw new IllegalArgumentException("Theta (angle) must be a finite number.");
+        }
+        double theta = Math.toRadians(thetaDegrees);
+        double x = r * Math.cos(theta);
+        double y = r * Math.sin(theta);
+        return new double[] {x, y};
+    }
+}

src/main/java/com/thealgorithms/dynamicprogramming/PartitionProblem.java

@@ -1,3 +1,5 @@
+package com.thealgorithms.dynamicprogramming;
+import java.util.Arrays;
 /**
  * @author Md Asif Joardar
  *
@@ -13,11 +15,6 @@
  *
  * The time complexity of the solution is O(n × sum) and requires O(n × sum) space
  */
-
-package com.thealgorithms.dynamicprogramming;
-
-import java.util.Arrays;
-
 public final class PartitionProblem {
     private PartitionProblem() {
     }

src/main/java/com/thealgorithms/geometry/Haversine.java

@@ -0,0 +1,49 @@
+package com.thealgorithms.geometry;
+/**
+ * This Class implements the Haversine formula to calculate the distance between two points on a sphere (like Earth) from their latitudes and longitudes.
+ *
+ * The Haversine formula is used in navigation and mapping to find the great-circle distance,
+ * which is the shortest distance between two points along the surface of a sphere. It is often
+ * used to calculate the "as the crow flies" distance between two geographical locations.
+ *
+ * The formula is reliable for all distances, including small ones, and avoids issues with
+ * numerical instability that can affect other methods.
+ *
+ * @see "https://en.wikipedia.org/wiki/Haversine_formula" - Wikipedia
+ */
+public final class Haversine {
+
+    // Average radius of Earth in kilometers
+    private static final double EARTH_RADIUS_KM = 6371.0;
+
+    /**
+     * Private constructor to prevent instantiation of this utility class.
+     */
+    private Haversine() {
+    }
+
+    /**
+     * Calculates the great-circle distance between two points on the earth
+     * (specified in decimal degrees).
+     *
+     * @param lat1 Latitude of the first point in decimal degrees.
+     * @param lon1 Longitude of the first point in decimal degrees.
+     * @param lat2 Latitude of the second point in decimal degrees.
+     * @param lon2 Longitude of the second point in decimal degrees.
+     * @return The distance between the two points in kilometers.
+     */
+    public static double haversine(double lat1, double lon1, double lat2, double lon2) {
+        // Convert latitude and longitude from degrees to radians
+        double dLat = Math.toRadians(lat2 - lat1);
+        double dLon = Math.toRadians(lon2 - lon1);
+
+        double lat1Rad = Math.toRadians(lat1);
+        double lat2Rad = Math.toRadians(lat2);
+
+        // Apply the Haversine formula
+        double a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1Rad) * Math.cos(lat2Rad);
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+        return EARTH_RADIUS_KM * c;
+    }
+}

src/main/java/com/thealgorithms/graph/ZeroOneBfs.java

@@ -0,0 +1,77 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayDeque;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.List;
+
+/**
+ * 0-1 BFS for shortest paths on graphs with edges weighted 0 or 1.
+ *
+ * <p>Time Complexity: O(V + E). Space Complexity: O(V).
+ *
+ * <p>References:
+ * <ul>
+ *   <li>https://cp-algorithms.com/graph/01_bfs.html</li>
+ * </ul>
+ */
+public final class ZeroOneBfs {
+
+    private ZeroOneBfs() {
+        // Utility class; do not instantiate.
+    }
+
+    /**
+     * Computes shortest distances from {@code src} in a graph whose edges have weight 0 or 1.
+     *
+     * @param n the number of vertices, labeled {@code 0..n-1}
+     * @param adj adjacency list; for each vertex u, {@code adj.get(u)} is a list of pairs
+     *            {@code (v, w)} where {@code v} is a neighbor and {@code w} is 0 or 1
+     * @param src the source vertex
+     * @return an array of distances; {@code Integer.MAX_VALUE} denotes unreachable
+     * @throws IllegalArgumentException if {@code n < 0}, {@code src} is out of range,
+     *                                  or any edge has weight other than 0 or 1
+     */
+    public static int[] shortestPaths(int n, List<List<int[]>> adj, int src) {
+        if (n < 0 || src < 0 || src >= n) {
+            throw new IllegalArgumentException("Invalid n or src");
+        }
+        int[] dist = new int[n];
+        Arrays.fill(dist, Integer.MAX_VALUE);
+        Deque<Integer> dq = new ArrayDeque<>();
+
+        dist[src] = 0;
+        dq.addFirst(src);
+
+        while (!dq.isEmpty()) {
+            int u = dq.pollFirst();
+            List<int[]> edges = adj.get(u);
+            if (edges == null) {
+                continue;
+            }
+            for (int[] e : edges) {
+                if (e == null || e.length < 2) {
+                    continue;
+                }
+                int v = e[0];
+                int w = e[1];
+                if (v < 0 || v >= n) {
+                    continue; // ignore bad edges
+                }
+                if (w != 0 && w != 1) {
+                    throw new IllegalArgumentException("Edge weight must be 0 or 1");
+                }
+                int nd = dist[u] + w;
+                if (nd < dist[v]) {
+                    dist[v] = nd;
+                    if (w == 0) {
+                        dq.addFirst(v);
+                    } else {
+                        dq.addLast(v);
+                    }
+                }
+            }
+        }
+        return dist;
+    }
+}

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

@@ -0,0 +1,79 @@
+package com.thealgorithms.maths;
+
+/**
+ * A utility class for calculating the persistence of a number.
+ *
+ * <p>This class provides methods to calculate:
+ * <ul>
+ *   <li>Multiplicative persistence: The number of steps required to reduce a number to a single digit by multiplying its digits.</li>
+ *   <li>Additive persistence: The number of steps required to reduce a number to a single digit by summing its digits.</li>
+ * </ul>
+ *
+ * <p>This class is final and cannot be instantiated.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Persistence_of_a_number">Wikipedia: Persistence of a number</a>
+ */
+public final class NumberPersistence {
+
+    // Private constructor to prevent instantiation
+    private NumberPersistence() {
+    }
+
+    /**
+     * Calculates the multiplicative persistence of a given number.
+     *
+     * <p>Multiplicative persistence is the number of steps required to reduce a number to a single digit
+     * by multiplying its digits repeatedly.
+     *
+     * @param num the number to calculate persistence for; must be non-negative
+     * @return the multiplicative persistence of the number
+     * @throws IllegalArgumentException if the input number is negative
+     */
+    public static int multiplicativePersistence(int num) {
+        if (num < 0) {
+            throw new IllegalArgumentException("multiplicativePersistence() does not accept negative values");
+        }
+
+        int steps = 0;
+        while (num >= 10) {
+            int product = 1;
+            int temp = num;
+            while (temp > 0) {
+                product *= temp % 10;
+                temp /= 10;
+            }
+            num = product;
+            steps++;
+        }
+        return steps;
+    }
+
+    /**
+     * Calculates the additive persistence of a given number.
+     *
+     * <p>Additive persistence is the number of steps required to reduce a number to a single digit
+     * by summing its digits repeatedly.
+     *
+     * @param num the number to calculate persistence for; must be non-negative
+     * @return the additive persistence of the number
+     * @throws IllegalArgumentException if the input number is negative
+     */
+    public static int additivePersistence(int num) {
+        if (num < 0) {
+            throw new IllegalArgumentException("additivePersistence() does not accept negative values");
+        }
+
+        int steps = 0;
+        while (num >= 10) {
+            int sum = 0;
+            int temp = num;
+            while (temp > 0) {
+                sum += temp % 10;
+                temp /= 10;
+            }
+            num = sum;
+            steps++;
+        }
+        return steps;
+    }
+}

src/main/java/com/thealgorithms/recursion/SylvesterSequence.java

@@ -0,0 +1,50 @@
+package com.thealgorithms.recursion;
+
+import java.math.BigInteger;
+
+/**
+ * A utility class for calculating numbers in Sylvester's sequence.
+ *
+ * <p>Sylvester's sequence is a sequence of integers where each term is calculated
+ * using the formula:
+ * <pre>
+ * a(n) = a(n-1) * (a(n-1) - 1) + 1
+ * </pre>
+ * with the first term being 2.
+ *
+ * <p>This class is final and cannot be instantiated.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Sylvester_sequence">Wikipedia: Sylvester sequence</a>
+ */
+public final class SylvesterSequence {
+
+    // Private constructor to prevent instantiation
+    private SylvesterSequence() {
+    }
+
+    /**
+     * Calculates the nth number in Sylvester's sequence.
+     *
+     * <p>The sequence is defined recursively, with the first term being 2:
+     * <pre>
+     * a(1) = 2
+     * a(n) = a(n-1) * (a(n-1) - 1) + 1 for n > 1
+     * </pre>
+     *
+     * @param n the position in the sequence (must be greater than 0)
+     * @return the nth number in Sylvester's sequence
+     * @throws IllegalArgumentException if n is less than or equal to 0
+     */
+    public static BigInteger sylvester(int n) {
+        if (n <= 0) {
+            throw new IllegalArgumentException("sylvester() does not accept negative numbers or zero.");
+        }
+        if (n == 1) {
+            return BigInteger.valueOf(2);
+        } else {
+            BigInteger prev = sylvester(n - 1);
+            // Sylvester sequence formula: a(n) = a(n-1) * (a(n-1) - 1) + 1
+            return prev.multiply(prev.subtract(BigInteger.ONE)).add(BigInteger.ONE);
+        }
+    }
+}

src/test/java/com/thealgorithms/conversions/CoordinateConverterTest.java

@@ -0,0 +1,34 @@
+package com.thealgorithms.conversions;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+public class CoordinateConverterTest {
+
+    @ParameterizedTest
+    @CsvSource({"0, 0, 0, 0", "1, 0, 1, 0", "0, 1, 1, 90", "-1, 0, 1, 180", "0, -1, 1, -90", "3, 4, 5, 53.13010235415599"})
+    void testCartesianToPolar(double x, double y, double expectedR, double expectedTheta) {
+        assertArrayEquals(new double[] {expectedR, expectedTheta}, CoordinateConverter.cartesianToPolar(x, y), 1e-9);
+    }
+
+    @ParameterizedTest
+    @CsvSource({"1, 0, 1, 0", "1, 90, 0, 1", "1, 180, -1, 0", "1, -90, 0, -1", "5, 53.13010235415599, 3, 4"})
+    void testPolarToCartesian(double r, double theta, double expectedX, double expectedY) {
+        assertArrayEquals(new double[] {expectedX, expectedY}, CoordinateConverter.polarToCartesian(r, theta), 1e-9);
+    }
+
+    @ParameterizedTest
+    @CsvSource({"NaN, 1", "1, NaN", "Infinity, 1", "1, Infinity", "-Infinity, 1", "1, -Infinity"})
+    void testCartesianToPolarInvalidInputs(double x, double y) {
+        assertThrows(IllegalArgumentException.class, () -> CoordinateConverter.cartesianToPolar(x, y));
+    }
+
+    @ParameterizedTest
+    @CsvSource({"-1, 0", "1, NaN", "1, Infinity", "1, -Infinity"})
+    void testPolarToCartesianInvalidInputs(double r, double theta) {
+        assertThrows(IllegalArgumentException.class, () -> CoordinateConverter.polarToCartesian(r, theta));
+    }
+}