Merge branch 'master' into fix-7456-group-palindrome-implementations

Author: DenizAltunkapan

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

@@ -119,8 +119,15 @@ public static byte[] decode(String input) {
 
         // Validate padding: '=' can only appear at the end (last 1 or 2 chars)
         int firstPadding = input.indexOf('=');
-        if (firstPadding != -1 && firstPadding < input.length() - 2) {
-            throw new IllegalArgumentException("Padding '=' can only appear at the end (last 1 or 2 characters)");
+        if (firstPadding != -1) {
+            if (firstPadding < input.length() - 2) {
+                throw new IllegalArgumentException("Padding '=' can only appear at the end (last 1 or 2 characters)");
+            }
+            for (int i = firstPadding; i < input.length(); i++) {
+                if (input.charAt(i) != '=') {
+                    throw new IllegalArgumentException("A padding '=' must not be followed by a non-padding character");
+                }
+            }
         }
 
         List<Byte> result = new ArrayList<>();

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

@@ -1,6 +1,7 @@
 package com.thealgorithms.datastructures.graphs;
 
 import java.util.Arrays;
+import java.util.PriorityQueue;
 
 /**
  * Dijkstra's algorithm for finding the shortest path from a single source vertex to all other vertices in a graph.
@@ -18,6 +19,21 @@ public DijkstraAlgorithm(int vertexCount) {
         this.vertexCount = vertexCount;
     }
 
+    private static class Node implements Comparable<Node> {
+        int id;
+        int distance;
+
+        Node(int id, int distance) {
+            this.id = id;
+            this.distance = distance;
+        }
+
+        @Override
+        public int compareTo(Node other) {
+            return Integer.compare(this.distance, other.distance);
+        }
+    }
+
     /**
      * Executes Dijkstra's algorithm on the provided graph to find the shortest paths from the source vertex to all other vertices.
      *
@@ -36,18 +52,25 @@ public int[] run(int[][] graph, int source) {
 
         int[] distances = new int[vertexCount];
         boolean[] processed = new boolean[vertexCount];
+        PriorityQueue<Node> unprocessed = new PriorityQueue<>();
 
         Arrays.fill(distances, Integer.MAX_VALUE);
-        Arrays.fill(processed, false);
         distances[source] = 0;
+        unprocessed.add(new Node(source, 0));
+
+        while (!unprocessed.isEmpty()) {
+            Node current = unprocessed.poll();
+            int u = current.id;
 
-        for (int count = 0; count < vertexCount - 1; count++) {
-            int u = getMinDistanceVertex(distances, processed);
+            if (processed[u]) {
+                continue;
+            }
             processed[u] = true;
 
             for (int v = 0; v < vertexCount; v++) {
                 if (!processed[v] && graph[u][v] != 0 && distances[u] != Integer.MAX_VALUE && distances[u] + graph[u][v] < distances[v]) {
                     distances[v] = distances[u] + graph[u][v];
+                    unprocessed.add(new Node(v, distances[v]));
                 }
             }
         }
@@ -56,27 +79,6 @@ public int[] run(int[][] graph, int source) {
         return distances;
     }
 
-    /**
-     * Finds the vertex with the minimum distance value from the set of vertices that have not yet been processed.
-     *
-     * @param distances The array of current shortest distances from the source vertex.
-     * @param processed The array indicating whether each vertex has been processed.
-     * @return The index of the vertex with the minimum distance value.
-     */
-    private int getMinDistanceVertex(int[] distances, boolean[] processed) {
-        int min = Integer.MAX_VALUE;
-        int minIndex = -1;
-
-        for (int v = 0; v < vertexCount; v++) {
-            if (!processed[v] && distances[v] <= min) {
-                min = distances[v];
-                minIndex = v;
-            }
-        }
-
-        return minIndex;
-    }
-
     /**
      * Prints the shortest distances from the source vertex to all other vertices.
      *

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

@@ -0,0 +1,49 @@
+package com.thealgorithms.maths;
+
+/**
+ * Two numbers are Friendly if they share the same abundancy index,
+ * which is the ratio of the sum of divisors to the number itself.
+ * Example: 6 and 28 are friendly because sigma(6)/6 = 2 and sigma(28)/28 = 2
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Friendly_number">
+ *     Wikipedia: Friendly Number</a>
+ *
+ * @author Vraj Prajapati @Rosander0
+ */
+public final class FriendlyNumber {
+
+    private FriendlyNumber() {
+        // Utility class
+    }
+
+    private static int sumOfDivisors(final int number) {
+        int sum = 0;
+        final int root = (int) Math.sqrt(number);
+        for (int i = 1; i <= root; i++) {
+            if (number % i == 0) {
+                sum += i;
+                final int other = number / i;
+                if (other != i) {
+                    sum += other;
+                }
+            }
+        }
+        return sum;
+    }
+
+    /**
+     * Checks whether two numbers are Friendly Numbers.
+     *
+     * @param a First number (must be positive)
+     * @param b Second number (must be positive)
+     * @return true if a and b are friendly numbers, false otherwise
+     */
+    public static boolean areFriendly(final int a, final int b) {
+        if (a <= 0 || b <= 0) {
+            return false;
+        }
+        final long sigmaA = sumOfDivisors(a);
+        final long sigmaB = sumOfDivisors(b);
+        return sigmaA * b == sigmaB * a;
+    }
+}

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

@@ -0,0 +1,67 @@
+package com.thealgorithms.maths;
+
+/**
+ * Sociable numbers are natural numbers that form a cyclic sequence where the
+ * sum of proper divisors of each number equals the next number in the sequence,
+ * with the sequence eventually returning to the starting number.
+ * Amicable numbers are a special case of sociable numbers with a cycle length of 2.
+ * Example: (12496, 14288, 15472, 14536, 14264) is a sociable cycle of length 5.
+ *
+ * @author Vraj Prajapati (@Rosander0)
+ * @see <a href="https://en.wikipedia.org/wiki/Sociable_number">Wikipedia: Sociable Number</a>
+ * @see AmicableNumber
+ */
+public final class SociableNumber {
+
+    private SociableNumber() {
+        // Utility class
+    }
+
+    /**
+     * Calculates the sum of proper divisors of a number
+     * (all divisors excluding the number itself).
+     *
+     * @param number the number to calculate proper divisors sum for
+     * @return sum of proper divisors, or 0 if number is less than or equal to 1
+     */
+    static int sumOfProperDivisors(final int number) {
+        if (number <= 1) {
+            return 0;
+        }
+        int sum = 1; // 1 is a proper divisor of every number > 1
+        final int root = (int) Math.sqrt(number);
+        for (int i = 2; i <= root; i++) {
+            if (number % i == 0) {
+                final int other = number / i;
+                sum += i;
+                if (other != i) {
+                    sum += other;
+                }
+            }
+        }
+        return sum;
+    }
+
+    /**
+     * Checks whether a number is part of a sociable cycle of a given length.
+     * Starting from the given number, it follows the chain of proper divisor
+     * sums and checks if it returns to the starting number in exactly cycleLength steps.
+     *
+     * @param number the starting number (must be positive)
+     * @param cycleLength the expected cycle length (must be greater than 1)
+     * @return true if the number is part of a sociable cycle of given length, false otherwise
+     */
+    public static boolean isSociable(final int number, final int cycleLength) {
+        if (number <= 0 || cycleLength <= 1) {
+            return false;
+        }
+        int current = number;
+        for (int i = 0; i < cycleLength; i++) {
+            current = sumOfProperDivisors(current);
+            if (current == number) {
+                return i == cycleLength - 1;
+            }
+        }
+        return false;
+    }
+}

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

@@ -127,6 +127,9 @@ void testInvalidPaddingPosition() {
         assertThrows(IllegalArgumentException.class, () -> Base64.decode("Q=QQ"));
         assertThrows(IllegalArgumentException.class, () -> Base64.decode("Q=Q="));
         assertThrows(IllegalArgumentException.class, () -> Base64.decode("=QQQ"));
+        assertThrows(IllegalArgumentException.class, () -> Base64.decode("QQ=Q"));
+        assertThrows(IllegalArgumentException.class, () -> Base64.decode("AB=C"));
+        assertThrows(IllegalArgumentException.class, () -> Base64.decode("AB=A"));
     }
 
     @Test

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

@@ -0,0 +1,33 @@
+package com.thealgorithms.maths;
+// author: Vraj Prajapati @Rosander0
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class FriendlyNumberTest {
+
+    @Test
+    public void testFriendlyNumbers() {
+        // 6 and 28 are friendly (abundancy index = 2)
+        assertTrue(FriendlyNumber.areFriendly(6, 28));
+        // Every number is friendly with itself
+        assertTrue(FriendlyNumber.areFriendly(6, 6));
+        assertTrue(FriendlyNumber.areFriendly(1, 1));
+    }
+
+    @Test
+    public void testNonFriendlyNumbers() {
+        assertFalse(FriendlyNumber.areFriendly(6, 10));
+        assertFalse(FriendlyNumber.areFriendly(10, 15));
+        assertFalse(FriendlyNumber.areFriendly(4, 9));
+    }
+
+    @Test
+    public void testInvalidInputs() {
+        assertFalse(FriendlyNumber.areFriendly(0, 6));
+        assertFalse(FriendlyNumber.areFriendly(-1, 6));
+        assertFalse(FriendlyNumber.areFriendly(6, -1));
+    }
+}