Merge branch 'master' into fix-7482-base64-padding-validation

Author: DenizAltunkapan

…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

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

src/main/java/com/thealgorithms/maths/FriendlyNumber.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/PadovanSequence.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/searches/InterpolationSearch.java

@@ -36,9 +36,12 @@ public int find(int[] array, int key) {
         // Since array is sorted, an element present
         // in array must be in range defined by corner
         while (start <= end && key >= array[start] && key <= array[end]) {
+            if (array[start] == array[end]) {
+                return start;
+            }
             // Probing the position with keeping
             // uniform distribution in mind.
-            int pos = start + (((end - start) / (array[end] - array[start])) * (key - array[start]));
+            int pos = start + (int) (((long) (end - start) * (key - array[start])) / ((long) array[end] - array[start]));
 
             // Condition of target found
             if (array[pos] == key) {

…ms/tree/HeavyLightDecompositionTest.java …s/trees/HeavyLightDecompositionTest.javasrc/test/java/com/thealgorithms/tree/HeavyLightDecompositionTest.java renamed to src/test/java/com/thealgorithms/datastructures/trees/HeavyLightDecompositionTest.java src/test/java/com/thealgorithms/tree/HeavyLightDecompositionTest.java renamed to src/test/java/com/thealgorithms/datastructures/trees/HeavyLightDecompositionTest.java

@@ -1,4 +1,4 @@
-package com.thealgorithms.tree;
+package com.thealgorithms.datastructures.trees;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;

src/test/java/com/thealgorithms/maths/FriendlyNumberTest.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));
+    }
+}

src/test/java/com/thealgorithms/maths/PadovanSequenceTest.java

@@ -0,0 +1,36 @@
+package com.thealgorithms.maths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author Vraj Prajapati (@Rosander0)
+ */
+public class PadovanSequenceTest {
+
+    @Test
+    public void testBaseCase() {
+        assertEquals(1, PadovanSequence.padovan(0));
+        assertEquals(1, PadovanSequence.padovan(1));
+        assertEquals(1, PadovanSequence.padovan(2));
+    }
+
+    @Test
+    public void testKnownValues() {
+        assertEquals(2, PadovanSequence.padovan(3));
+        assertEquals(2, PadovanSequence.padovan(4));
+        assertEquals(3, PadovanSequence.padovan(5));
+        assertEquals(4, PadovanSequence.padovan(6));
+        assertEquals(5, PadovanSequence.padovan(7));
+        assertEquals(7, PadovanSequence.padovan(8));
+        assertEquals(9, PadovanSequence.padovan(9));
+        assertEquals(12, PadovanSequence.padovan(10));
+    }
+
+    @Test
+    public void testInvalidInput() {
+        assertThrows(IllegalArgumentException.class, () -> PadovanSequence.padovan(-1));
+    }
+}

src/test/java/com/thealgorithms/searches/InterpolationSearchTest.java

@@ -87,4 +87,15 @@ void testInterpolationSearchLargeNonUniformArray() {
         int key = 21; // Present in the array
         assertEquals(6, interpolationSearch.find(array, key), "The index of the found element should be 6.");
     }
+
+    /**
+     * Test for interpolation search with specific sorted arrays that previously caused division by zero.
+     */
+    @Test
+    void testInterpolationSearchDivisionByZeroEdgeCases() {
+        InterpolationSearch interpolationSearch = new InterpolationSearch();
+        assertEquals(3, interpolationSearch.find(new int[] {0, 0, 0, 2}, 2));
+        assertEquals(0, interpolationSearch.find(new int[] {2, 2, 2, 2}, 2));
+        assertEquals(3, interpolationSearch.find(new int[] {0, 1, 2, 4}, 4));
+    }
 }