Merge branch 'master' into add-friendly-number

DenizAltunkapan · web-flow · commit c7dbdceb7653 · 2026-06-22T09:22:02.000+02:00
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -8,7 +8,7 @@ jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - name: Set up JDK
         uses: actions/setup-java@v5
         with:
diff --git a/.github/workflows/clang-format-lint.yml b/.github/workflows/clang-format-lint.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v7
     - uses: DoozyX/clang-format-lint-action@v0.20
       with:
         source: './src'
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
@@ -21,7 +21,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Set up JDK
         uses: actions/setup-java@v5
@@ -52,7 +52,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v4
diff --git a/.github/workflows/infer.yml b/.github/workflows/infer.yml
@@ -15,7 +15,7 @@ jobs:
   run_infer:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
 
       - name: Set up JDK
         uses: actions/setup-java@v5
diff --git a/.github/workflows/project_structure.yml b/.github/workflows/project_structure.yml
@@ -15,7 +15,7 @@ jobs:
   check_structure:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: actions/setup-python@v6
         with:
           python-version: '3.13'
diff --git a/.github/workflows/update-directorymd.yml b/.github/workflows/update-directorymd.yml
@@ -1,4 +1,4 @@
-﻿name: Generate Directory Markdown
+name: Generate Directory Markdown
 
 on:
   push:
@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout Repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v7
         with:
           persist-credentials: false
 
diff --git a/pom.xml b/pom.xml
@@ -112,7 +112,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>13.5.0</version>
+                    <version>13.6.0</version>
                     </dependency>
                 </dependencies>
             </plugin>
diff --git a/src/main/java/com/thealgorithms/datastructures/trees/HeavyLightDecomposition.java b/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;
diff --git a/src/main/java/com/thealgorithms/maths/JacobsthalNumber.java b/src/main/java/com/thealgorithms/maths/JacobsthalNumber.java
@@ -0,0 +1,44 @@
+package com.thealgorithms.maths;
+// author: Vraj Prajapati @Rosander0
+
+/**
+ * The Jacobsthal Sequence is a sequence of integers defined by the recurrence relation:
+ * J(n) = J(n-1) + 2*J(n-2) with initial values J(0) = 0, J(1) = 1.
+ * Example: 0, 1, 1, 3, 5, 11, 21, 43, 85, 171, 341...
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Jacobsthal_number">
+ *     Wikipedia: Jacobsthal Number</a>
+ */
+public final class JacobsthalNumber {
+
+    private JacobsthalNumber() {
+        // Utility class
+    }
+
+    /**
+     * Calculates the nth term of the Jacobsthal Sequence.
+     *
+     * @param n the index of the sequence (must be non-negative)
+     * @return the nth term of the Jacobsthal Sequence
+     */
+    public static long jacobsthal(final int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative!");
+        }
+        if (n == 0) {
+            return 0;
+        }
+        if (n == 1) {
+            return 1;
+        }
+        long a = 0;
+        long b = 1;
+        long result = 0;
+        for (int i = 2; i <= n; i++) {
+            result = b + 2 * a;
+            a = b;
+            b = result;
+        }
+        return result;
+    }
+}
diff --git a/src/main/java/com/thealgorithms/maths/PadovanSequence.java b/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;
+    }
+}
diff --git a/src/main/java/com/thealgorithms/maths/PerrinNumber.java b/src/main/java/com/thealgorithms/maths/PerrinNumber.java
@@ -0,0 +1,53 @@
+package com.thealgorithms.maths;
+// author: Vraj Prajapati @Rosander0
+
+/**
+ * The Perrin Sequence is a sequence of integers defined by the recurrence relation:
+ * P(n) = P(n-2) + P(n-3) with initial values P(0) = 3, P(1) = 0, P(2) = 2.
+ * Example: 3, 0, 2, 3, 2, 5, 5, 7, 10, 12, 17, 22, 29, 39, 51...
+ *
+ * Note: The Perrin Sequence uses the same recurrence relation as the Padovan Sequence
+ * but has different initial values.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Perrin_number">
+ *     Wikipedia: Perrin Number</a>
+ * @see PadovanSequence
+ */
+public final class PerrinNumber {
+
+    private PerrinNumber() {
+        // Utility class
+    }
+
+    /**
+     * Calculates the nth term of the Perrin Sequence.
+     *
+     * @param n the index of the sequence (must be non-negative)
+     * @return the nth term of the Perrin Sequence
+     */
+    public static long perrin(final int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input must be non-negative!");
+        }
+        if (n == 0) {
+            return 3;
+        }
+        if (n == 1) {
+            return 0;
+        }
+        if (n == 2) {
+            return 2;
+        }
+        long a = 3;
+        long b = 0;
+        long c = 2;
+        long result = 0;
+        for (int i = 3; i <= n; i++) {
+            result = a + b;
+            a = b;
+            b = c;
+            c = result;
+        }
+        return result;
+    }
+}
diff --git a/src/main/java/com/thealgorithms/searches/InterpolationSearch.java b/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) {
diff --git a/src/main/java/com/thealgorithms/slidingwindow/CountDistinctElementsInWindow.java b/src/main/java/com/thealgorithms/slidingwindow/CountDistinctElementsInWindow.java
@@ -0,0 +1,57 @@
+package com.thealgorithms.slidingwindow;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Counts the number of distinct elements in every window of size k.
+ *
+ * @see <a href="https://www.geeksforgeeks.org/count-distinct-elements-in-every-window-of-size-k/">Reference</a>
+ */
+public final class CountDistinctElementsInWindow {
+
+    private CountDistinctElementsInWindow() {
+    }
+
+    /**
+     * Returns an array where each element is the count of distinct
+     * elements in the corresponding window of size k.
+     *
+     * @param arr the input array
+     * @param k   the window size
+     * @return array of distinct element counts per window
+     */
+    public static int[] countDistinct(int[] arr, int k) {
+        if (arr == null || arr.length == 0 || k <= 0 || k > arr.length) {
+            throw new IllegalArgumentException("Invalid input");
+        }
+
+        int n = arr.length;
+        int[] result = new int[n - k + 1];
+        Map<Integer, Integer> freqMap = new HashMap<>();
+
+        for (int i = 0; i < k; i++) {
+            freqMap.merge(arr[i], 1, Integer::sum);
+        }
+        result[0] = freqMap.size();
+
+        for (int i = k; i < n; i++) {
+            freqMap.merge(arr[i], 1, Integer::sum);
+
+            int outgoing = arr[i - k];
+
+            Integer count = freqMap.get(outgoing);
+            if (count != null) {
+                if (count == 1) {
+                    freqMap.remove(outgoing);
+                } else {
+                    freqMap.put(outgoing, count - 1);
+                }
+            }
+
+            result[i - k + 1] = freqMap.size();
+        }
+
+        return result;
+    }
+}
diff --git a/src/main/java/com/thealgorithms/strings/LongestCommonSubstring.java b/src/main/java/com/thealgorithms/strings/LongestCommonSubstring.java
@@ -0,0 +1,55 @@
+package com.thealgorithms.strings;
+
+/**
+ * Longest Common Substring finds the longest string that is a
+ * contiguous substring of two input strings.
+ * Example: "abcdef" and "zcdemf" -> "cde"
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Longest_common_substring">
+ *     Wikipedia: Longest Common Substring</a>
+ *
+ * author: Vraj Prajapati @Rosander0
+ */
+public final class LongestCommonSubstring {
+
+    private LongestCommonSubstring() {
+        // Utility class
+    }
+
+    /**
+     * Finds the longest common substring of two strings.
+     *
+     * @param a First input string
+     * @param b Second input string
+     * @return The longest common substring, or empty string if none exists.
+     *     If multiple substrings share the maximum length, the first one found is returned.
+     */
+    public static String longestCommonSubstring(final String a, final String b) {
+        if (a == null || b == null || a.isEmpty() || b.isEmpty()) {
+            return "";
+        }
+
+        int[][] dp = new int[a.length() + 1][b.length() + 1];
+        int maxLength = 0;
+        int endIndex = 0;
+
+        for (int i = 1; i <= a.length(); i++) {
+            for (int j = 1; j <= b.length(); j++) {
+                if (a.charAt(i - 1) == b.charAt(j - 1)) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                    if (dp[i][j] > maxLength) {
+                        maxLength = dp[i][j];
+                        endIndex = i;
+                    }
+                } else {
+                    dp[i][j] = 0;
+                }
+            }
+        }
+
+        if (maxLength == 0) {
+            return "";
+        }
+        return a.substring(endIndex - maxLength, endIndex);
+    }
+}
diff --git a/src/test/java/com/thealgorithms/datastructures/trees/HeavyLightDecompositionTest.java b/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;
diff --git a/src/test/java/com/thealgorithms/maths/JacobsthalNumberTest.java b/src/test/java/com/thealgorithms/maths/JacobsthalNumberTest.java
@@ -0,0 +1,34 @@
+package com.thealgorithms.maths;
+// author: Vraj Prajapati @Rosander0
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+public class JacobsthalNumberTest {
+
+    @Test
+    public void testBaseCases() {
+        assertEquals(0, JacobsthalNumber.jacobsthal(0));
+        assertEquals(1, JacobsthalNumber.jacobsthal(1));
+    }
+
+    @Test
+    public void testKnownValues() {
+        assertEquals(1, JacobsthalNumber.jacobsthal(2));
+        assertEquals(3, JacobsthalNumber.jacobsthal(3));
+        assertEquals(5, JacobsthalNumber.jacobsthal(4));
+        assertEquals(11, JacobsthalNumber.jacobsthal(5));
+        assertEquals(21, JacobsthalNumber.jacobsthal(6));
+        assertEquals(43, JacobsthalNumber.jacobsthal(7));
+        assertEquals(85, JacobsthalNumber.jacobsthal(8));
+        assertEquals(171, JacobsthalNumber.jacobsthal(9));
+        assertEquals(341, JacobsthalNumber.jacobsthal(10));
+    }
+
+    @Test
+    public void testInvalidInput() {
+        assertThrows(IllegalArgumentException.class, () -> JacobsthalNumber.jacobsthal(-1));
+    }
+}
diff --git a/src/test/java/com/thealgorithms/maths/PadovanSequenceTest.java b/src/test/java/com/thealgorithms/maths/PadovanSequenceTest.java
diff --git a/src/test/java/com/thealgorithms/maths/PerrinNumberTest.java b/src/test/java/com/thealgorithms/maths/PerrinNumberTest.java
diff --git a/src/test/java/com/thealgorithms/searches/InterpolationSearchTest.java b/src/test/java/com/thealgorithms/searches/InterpolationSearchTest.java
diff --git a/src/test/java/com/thealgorithms/slidingwindow/CountDistinctElementsInWindowTest.java b/src/test/java/com/thealgorithms/slidingwindow/CountDistinctElementsInWindowTest.java
diff --git a/src/test/java/com/thealgorithms/strings/LongestCommonSubstringTest.java b/src/test/java/com/thealgorithms/strings/LongestCommonSubstringTest.java

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-package com.thealgorithms.tree;`
	`1`	`+package com.thealgorithms.datastructures.trees;`
`2`	`2`
`3`	`3`	`import java.util.ArrayList;`
`4`	`4`	`import java.util.List;`