Merge branch 'master' into feature-7443-jdk-compatibility-matrix

Author: priyanshuvishwakarma273403

src/main/java/com/thealgorithms/bitmanipulation/BinaryPalindromeCheck.java

@@ -9,6 +9,12 @@
  * </p>
  *
  * @author Hardvan
+ * @see com.thealgorithms.strings.Palindrome
+ * @see com.thealgorithms.stacks.PalindromeWithStack
+ * @see com.thealgorithms.maths.LowestBasePalindrome
+ * @see com.thealgorithms.datastructures.lists.PalindromeSinglyLinkedList
+ * @see com.thealgorithms.maths.PalindromePrime
+ * @see com.thealgorithms.maths.PalindromeNumber
  */
 public final class BinaryPalindromeCheck {
     private BinaryPalindromeCheck() {

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

@@ -1,4 +1,4 @@
-package com.thealgorithms.misc;
+package com.thealgorithms.datastructures.lists;
 
 import java.util.Stack;
 
@@ -9,6 +9,13 @@
  *
  * See more:
  * https://www.geeksforgeeks.org/function-to-check-if-a-singly-linked-list-is-palindrome/
+ *
+ * @see com.thealgorithms.strings.Palindrome
+ * @see com.thealgorithms.stacks.PalindromeWithStack
+ * @see com.thealgorithms.bitmanipulation.BinaryPalindromeCheck
+ * @see com.thealgorithms.maths.LowestBasePalindrome
+ * @see com.thealgorithms.maths.PalindromePrime
+ * @see com.thealgorithms.maths.PalindromeNumber
  */
 @SuppressWarnings("rawtypes")
 public final class PalindromeSinglyLinkedList {

…hms/misc/PalindromeSinglyLinkedList.java …es/lists/PalindromeSinglyLinkedList.javasrc/main/java/com/thealgorithms/misc/PalindromeSinglyLinkedList.java renamed to src/main/java/com/thealgorithms/datastructures/lists/PalindromeSinglyLinkedList.java src/main/java/com/thealgorithms/misc/PalindromeSinglyLinkedList.java renamed to src/main/java/com/thealgorithms/datastructures/lists/PalindromeSinglyLinkedList.java

@@ -1,4 +1,4 @@
-package com.thealgorithms.tree;
+package com.thealgorithms.datastructures.trees;
 
 import java.util.ArrayList;
 import java.util.List;

…rithms/tree/HeavyLightDecomposition.java …tures/trees/HeavyLightDecomposition.javasrc/main/java/com/thealgorithms/tree/HeavyLightDecomposition.java renamed to src/main/java/com/thealgorithms/datastructures/trees/HeavyLightDecomposition.java src/main/java/com/thealgorithms/tree/HeavyLightDecomposition.java renamed to src/main/java/com/thealgorithms/datastructures/trees/HeavyLightDecomposition.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

@@ -1,4 +1,4 @@
-package com.thealgorithms.others;
+package com.thealgorithms.maths;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -23,6 +23,12 @@
  *
  * @see <a href="https://oeis.org/A016026">OEIS A016026 - Smallest base in which
  *      n is palindromic</a>
+ * @see com.thealgorithms.strings.Palindrome
+ * @see com.thealgorithms.stacks.PalindromeWithStack
+ * @see com.thealgorithms.bitmanipulation.BinaryPalindromeCheck
+ * @see com.thealgorithms.datastructures.lists.PalindromeSinglyLinkedList
+ * @see com.thealgorithms.maths.PalindromePrime
+ * @see com.thealgorithms.maths.PalindromeNumber
  * @author TheAlgorithms Contributors
  */
 public final class LowestBasePalindrome {

…orithms/others/LowestBasePalindrome.java …gorithms/maths/LowestBasePalindrome.javasrc/main/java/com/thealgorithms/others/LowestBasePalindrome.java renamed to src/main/java/com/thealgorithms/maths/LowestBasePalindrome.java src/main/java/com/thealgorithms/others/LowestBasePalindrome.java renamed to src/main/java/com/thealgorithms/maths/LowestBasePalindrome.java

@@ -0,0 +1,43 @@
+package com.thealgorithms.maths;
+
+/**
+ * The Padovan Sequence is a sequence of integers defined by the recurrence relation:
+ * P(n) = P(n-2) + P(n-3) with initial values P(0) = P(1) = P(2) = 1.
+ * Example: 1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37...
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Padovan_sequence">
+ *     Wikipedia: Padovan Sequence</a>
+ * @author Vraj Prajapati (@Rosander0)
+ */
+public final class PadovanSequence {
+
+    private PadovanSequence() {
+        // Utility class
+    }
+
+    /**
+     * Calculates the nth term of the Padovan Sequence.
+     *
+     * @param n the index of the sequence (must be non-negative)
+     * @return the nth term of the Padovan Sequence
+     */
+    public static long padovan(final int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative. Received: " + n);
+        }
+        if (n <= 2) {
+            return 1;
+        }
+        long a = 1;
+        long b = 1;
+        long c = 1;
+        long result = 0;
+        for (int i = 3; i <= n; i++) {
+            result = a + b;
+            a = b;
+            b = c;
+            c = result;
+        }
+        return result;
+    }
+}

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

@@ -1,5 +1,16 @@
 package com.thealgorithms.maths;
 
+/**
+ * A class to check if a given number is a palindrome.
+ * A palindromic number is a number that remains the same when its digits are reversed.
+ *
+ * @see com.thealgorithms.strings.Palindrome
+ * @see com.thealgorithms.stacks.PalindromeWithStack
+ * @see com.thealgorithms.bitmanipulation.BinaryPalindromeCheck
+ * @see com.thealgorithms.maths.LowestBasePalindrome
+ * @see com.thealgorithms.datastructures.lists.PalindromeSinglyLinkedList
+ * @see com.thealgorithms.maths.PalindromePrime
+ */
 public final class PalindromeNumber {
     private PalindromeNumber() {
     }