Merge branch 'master' into patch-1

Author: YERRA-CHARAN

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

@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Close stale PRs
-        uses: actions/github-script@v8
+        uses: actions/github-script@v9
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}
           script: |

pom.xml

@@ -112,7 +112,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>13.4.0</version>
+                    <version>13.4.1</version>
                     </dependency>
                 </dependencies>
             </plugin>

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

@@ -38,7 +38,7 @@ public static void main(String[] args) throws Exception {
         System.out.println("Original Text:" + plainText);
         System.out.println("AES Key (Hex Form):" + bytesToHex(secKey.getEncoded()));
         System.out.println("Encrypted Text (Hex Form):" + bytesToHex(cipherText));
-        System.out.println("Descrypted Text:" + decryptedText);
+        System.out.println("Decryption successful. Decrypted text matches original: " + decryptedText.equals(plainText));
     }
 
     /**

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

@@ -3,7 +3,7 @@
  * <p>
  * Time Complexity: O(n) [or appropriate complexity]
  * Space Complexity: O(n)
- * * @author Reshma Kakkirala
+ * @author Reshma Kakkirala
  */
 package com.thealgorithms.conversions;
 

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

@@ -0,0 +1,105 @@
+package com.thealgorithms.geometry;
+
+import java.awt.geom.Point2D;
+import java.util.Optional;
+
+/**
+ * Utility methods for checking and computing 2D line segment intersections.
+ */
+public final class LineIntersection {
+    private LineIntersection() {
+    }
+
+    /**
+     * Checks whether two line segments intersect.
+     *
+     * @param p1 first endpoint of segment 1
+     * @param p2 second endpoint of segment 1
+     * @param q1 first endpoint of segment 2
+     * @param q2 second endpoint of segment 2
+     * @return true when the segments intersect (including touching endpoints)
+     */
+    public static boolean intersects(Point p1, Point p2, Point q1, Point q2) {
+        int o1 = orientation(p1, p2, q1);
+        int o2 = orientation(p1, p2, q2);
+        int o3 = orientation(q1, q2, p1);
+        int o4 = orientation(q1, q2, p2);
+
+        if (o1 != o2 && o3 != o4) {
+            return true;
+        }
+
+        if (o1 == 0 && onSegment(p1, q1, p2)) {
+            return true;
+        }
+        if (o2 == 0 && onSegment(p1, q2, p2)) {
+            return true;
+        }
+        if (o3 == 0 && onSegment(q1, p1, q2)) {
+            return true;
+        }
+        if (o4 == 0 && onSegment(q1, p2, q2)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Computes the single geometric intersection point between two non-parallel
+     * segments when it exists.
+     *
+     * <p>For parallel/collinear overlap, this method returns {@code Optional.empty()}.
+     *
+     * @param p1 first endpoint of segment 1
+     * @param p2 second endpoint of segment 1
+     * @param q1 first endpoint of segment 2
+     * @param q2 second endpoint of segment 2
+     * @return the intersection point when uniquely defined and on both segments
+     */
+    public static Optional<Point2D.Double> intersectionPoint(Point p1, Point p2, Point q1, Point q2) {
+        if (!intersects(p1, p2, q1, q2)) {
+            return Optional.empty();
+        }
+
+        long x1 = p1.x();
+        long y1 = p1.y();
+        long x2 = p2.x();
+        long y2 = p2.y();
+        long x3 = q1.x();
+        long y3 = q1.y();
+        long x4 = q2.x();
+        long y4 = q2.y();
+
+        long denominator = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+        if (denominator == 0L) {
+            return sharedEndpoint(p1, p2, q1, q2);
+        }
+
+        long determinant1 = x1 * y2 - y1 * x2;
+        long determinant2 = x3 * y4 - y3 * x4;
+        long numeratorX = determinant1 * (x3 - x4) - (x1 - x2) * determinant2;
+        long numeratorY = determinant1 * (y3 - y4) - (y1 - y2) * determinant2;
+
+        return Optional.of(new Point2D.Double(numeratorX / (double) denominator, numeratorY / (double) denominator));
+    }
+
+    private static int orientation(Point a, Point b, Point c) {
+        long cross = ((long) b.x() - a.x()) * ((long) c.y() - a.y()) - ((long) b.y() - a.y()) * ((long) c.x() - a.x());
+        return Long.compare(cross, 0L);
+    }
+
+    private static Optional<Point2D.Double> sharedEndpoint(Point p1, Point p2, Point q1, Point q2) {
+        if (p1.equals(q1) || p1.equals(q2)) {
+            return Optional.of(new Point2D.Double(p1.x(), p1.y()));
+        }
+        if (p2.equals(q1) || p2.equals(q2)) {
+            return Optional.of(new Point2D.Double(p2.x(), p2.y()));
+        }
+        return Optional.empty();
+    }
+
+    private static boolean onSegment(Point a, Point b, Point c) {
+        return b.x() >= Math.min(a.x(), c.x()) && b.x() <= Math.max(a.x(), c.x()) && b.y() >= Math.min(a.y(), c.y()) && b.y() <= Math.max(a.y(), c.y());
+    }
+}

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

@@ -0,0 +1,112 @@
+package com.thealgorithms.graph;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Merges account records using Disjoint Set Union (Union-Find) on shared emails.
+ *
+ * <p>Input format: each account is a list where the first element is the user name and the
+ * remaining elements are emails.
+ */
+public final class AccountMerge {
+    private AccountMerge() {
+    }
+
+    public static List<List<String>> mergeAccounts(List<List<String>> accounts) {
+        if (accounts == null || accounts.isEmpty()) {
+            return List.of();
+        }
+
+        UnionFind dsu = new UnionFind(accounts.size());
+        Map<String, Integer> emailToAccount = new HashMap<>();
+
+        for (int i = 0; i < accounts.size(); i++) {
+            List<String> account = accounts.get(i);
+            for (int j = 1; j < account.size(); j++) {
+                String email = account.get(j);
+                Integer previous = emailToAccount.putIfAbsent(email, i);
+                if (previous != null) {
+                    dsu.union(i, previous);
+                }
+            }
+        }
+
+        Map<Integer, List<String>> rootToEmails = new LinkedHashMap<>();
+        for (Map.Entry<String, Integer> entry : emailToAccount.entrySet()) {
+            int root = dsu.find(entry.getValue());
+            rootToEmails.computeIfAbsent(root, ignored -> new ArrayList<>()).add(entry.getKey());
+        }
+        for (int i = 0; i < accounts.size(); i++) {
+            if (accounts.get(i).size() <= 1) {
+                int root = dsu.find(i);
+                rootToEmails.computeIfAbsent(root, ignored -> new ArrayList<>());
+            }
+        }
+
+        List<List<String>> merged = new ArrayList<>();
+        for (Map.Entry<Integer, List<String>> entry : rootToEmails.entrySet()) {
+            int root = entry.getKey();
+            List<String> emails = entry.getValue();
+            Collections.sort(emails);
+
+            List<String> mergedAccount = new ArrayList<>();
+            mergedAccount.add(accounts.get(root).getFirst());
+            mergedAccount.addAll(emails);
+            merged.add(mergedAccount);
+        }
+
+        merged.sort((a, b) -> {
+            int cmp = a.getFirst().compareTo(b.getFirst());
+            if (cmp != 0) {
+                return cmp;
+            }
+            if (a.size() == 1 || b.size() == 1) {
+                return Integer.compare(a.size(), b.size());
+            }
+            return a.get(1).compareTo(b.get(1));
+        });
+        return merged;
+    }
+
+    private static final class UnionFind {
+        private final int[] parent;
+        private final int[] rank;
+
+        private UnionFind(int size) {
+            this.parent = new int[size];
+            this.rank = new int[size];
+            for (int i = 0; i < size; i++) {
+                parent[i] = i;
+            }
+        }
+
+        private int find(int x) {
+            if (parent[x] != x) {
+                parent[x] = find(parent[x]);
+            }
+            return parent[x];
+        }
+
+        private void union(int x, int y) {
+            int rootX = find(x);
+            int rootY = find(y);
+            if (rootX == rootY) {
+                return;
+            }
+
+            if (rank[rootX] < rank[rootY]) {
+                parent[rootX] = rootY;
+            } else if (rank[rootX] > rank[rootY]) {
+                parent[rootY] = rootX;
+            } else {
+                parent[rootY] = rootX;
+                rank[rootX]++;
+            }
+        }
+    }
+}

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

@@ -1,9 +1,16 @@
 package com.thealgorithms.maths;
 
+import java.util.Arrays;
+import java.util.OptionalDouble;
+
 /**
  * A utility class for computing the average of numeric arrays.
- * This class provides static methods to calculate the average of arrays
- * of both {@code double} and {@code int} values.
+ *
+ * <p>This class provides static methods to calculate the arithmetic mean
+ * of arrays of both {@code double} and {@code int} values. It also offers
+ * a Stream-based alternative for modern, declarative usage.
+ *
+ * <p>All methods guard against {@code null} or empty inputs.
  */
 public final class Average {
 
@@ -13,11 +20,14 @@ private Average() {
     }
 
     /**
-     * Computes the average of a {@code double} array.
+     * Computes the arithmetic mean of a {@code double} array.
+     *
+     * <p>The average is calculated as the sum of all elements divided
+     * by the number of elements: {@code avg = Σ(numbers[i]) / n}.
      *
-     * @param numbers an array of {@code double} values
-     * @return the average of the given numbers
-     * @throws IllegalArgumentException if the input array is {@code null} or empty
+     * @param numbers a non-null, non-empty array of {@code double} values
+     * @return the arithmetic mean of the given numbers
+     * @throws IllegalArgumentException if {@code numbers} is {@code null} or empty
      */
     public static double average(double[] numbers) {
         if (numbers == null || numbers.length == 0) {
@@ -31,11 +41,14 @@ public static double average(double[] numbers) {
     }
 
     /**
-     * Computes the average of an {@code int} array.
+     * Computes the arithmetic mean of an {@code int} array.
+     *
+     * <p>The sum is accumulated in a {@code long} to prevent integer overflow
+     * when processing large arrays or large values.
      *
-     * @param numbers an array of {@code int} values
-     * @return the average of the given numbers
-     * @throws IllegalArgumentException if the input array is {@code null} or empty
+     * @param numbers a non-null, non-empty array of {@code int} values
+     * @return the arithmetic mean as a {@code long} (truncated toward zero)
+     * @throws IllegalArgumentException if {@code numbers} is {@code null} or empty
      */
     public static long average(int[] numbers) {
         if (numbers == null || numbers.length == 0) {
@@ -47,4 +60,21 @@ public static long average(int[] numbers) {
         }
         return sum / numbers.length;
     }
+
+    /**
+     * Computes the arithmetic mean of a {@code double} array using Java Streams.
+     *
+     * <p>This method is a declarative alternative to {@link #average(double[])}.
+     * Instead of throwing on empty input, it returns an empty {@link OptionalDouble},
+     * following the convention of the Stream API.
+     *
+     * @param numbers an array of {@code double} values, may be {@code null} or empty
+     * @return an {@link OptionalDouble} with the mean, or empty if input is null/empty
+     */
+    public static OptionalDouble averageStream(double[] numbers) {
+        if (numbers == null || numbers.length == 0) {
+            return OptionalDouble.empty();
+        }
+        return Arrays.stream(numbers).average();
+    }
 }

src/main/java/com/thealgorithms/searches/JumpSearch.java

@@ -36,6 +36,13 @@
  * <b>Space Complexity:</b> O(1) - only uses a constant amount of extra space
  *
  * <p>
+ * <b>Edge Cases:</b>
+ * <ul>
+ *   <li>Empty array → returns -1</li>
+ *   <li>Element not present → returns -1</li>
+ *   <li>Single element array</li>
+ * </ul>
+ * <p>
  * <b>Note:</b> Jump Search requires a sorted array. For unsorted arrays, use Linear Search.
  * Compared to Linear Search (O(n)), Jump Search is faster for large arrays.
  * Compared to Binary Search (O(log n)), Jump Search is less efficient but may be

src/main/java/com/thealgorithms/searches/SentinelLinearSearch.java

@@ -65,7 +65,8 @@ public <T extends Comparable<T>> int find(T[] array, T key) {
 
         int i = 0;
         // Search without bound checking since sentinel guarantees we'll find the key
-        while (array[i].compareTo(key) != 0) {
+        // Null check for array element to prevent NPE when array contains null elements
+        while (array[i] != null && array[i].compareTo(key) != 0) {
             i++;
         }