Merge branch 'master' into fibonacci_search_add_tests

Author: siriak

.github/workflows/build.yml

@@ -10,7 +10,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: 21
-          distribution: 'adopt'
+          distribution: 'temurin'
       - name: Build with Maven
         run: mvn --batch-mode --update-snapshots verify
       - name: Upload coverage to codecov (tokenless)

.github/workflows/codeql.yml

@@ -30,7 +30,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: 21
-          distribution: 'adopt'
+          distribution: 'temurin'
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v3

.github/workflows/infer.yml

@@ -18,7 +18,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           java-version: 21
-          distribution: 'adopt'
+          distribution: 'temurin'
 
       - name: Set up OCaml
         uses: ocaml/setup-ocaml@v3

DIRECTORY.md

@@ -262,6 +262,7 @@
             * [LongestValidParentheses](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/LongestValidParentheses.java)
             * [MatrixChainMultiplication](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/MatrixChainMultiplication.java)
             * [MatrixChainRecursiveTopDownMemoisation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/MatrixChainRecursiveTopDownMemoisation.java)
+            * [MaximumSumOfNonAdjacentElements](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/MaximumSumOfNonAdjacentElements.java)
             * [MinimumPathSum](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/MinimumPathSum.java)
             * [MinimumSumPartition](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/MinimumSumPartition.java)
             * [NewManShanksPrime](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/NewManShanksPrime.java)
@@ -815,12 +816,15 @@
             * [LongestPalindromicSubstringTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestPalindromicSubstringTest.java)
             * [LongestValidParenthesesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LongestValidParenthesesTest.java)
             * [MatrixChainMultiplicationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/MatrixChainMultiplicationTest.java)
+            * [MaximumSumOfNonAdjacentElementsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/MaximumSumOfNonAdjacentElementsTest.java)
             * [MinimumPathSumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/MinimumPathSumTest.java)
             * [MinimumSumPartitionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/MinimumSumPartitionTest.java)
+            * [NewManShanksPrimeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/NewManShanksPrimeTest.java)
             * [OptimalJobSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/OptimalJobSchedulingTest.java)
             * [PalindromicPartitioningTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/PalindromicPartitioningTest.java)
             * [PartitionProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/PartitionProblemTest.java)
             * [RegexMatchingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/RegexMatchingTest.java)
+            * [RodCuttingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/RodCuttingTest.java)
             * [ShortestCommonSupersequenceLengthTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/ShortestCommonSupersequenceLengthTest.java)
             * [SubsetCountTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SubsetCountTest.java)
             * [SubsetSumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SubsetSumTest.java)
@@ -829,6 +833,7 @@
             * [UniquePathsTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/UniquePathsTests.java)
             * [UniqueSubsequencesCountTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/UniqueSubsequencesCountTest.java)
             * [WildcardMatchingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/WildcardMatchingTest.java)
+            * [WineProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/WineProblemTest.java)
           * geometry
             * [GrahamScanTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/geometry/GrahamScanTest.java)
           * greedyalgorithms
@@ -992,6 +997,7 @@
             * [SRTFSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/SRTFSchedulingTest.java)
           * searches
             * [BinarySearch2dArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/BinarySearch2dArrayTest.java)
+            * [BinarySearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/BinarySearchTest.java)
             * [BM25InvertedIndexTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/BM25InvertedIndexTest.java)
             * [BreadthFirstSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/BreadthFirstSearchTest.java)
             * [DepthFirstSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/DepthFirstSearchTest.java)

src/main/java/com/thealgorithms/dynamicprogramming/MaximumSumOfNonAdjacentElements.java

@@ -0,0 +1,95 @@
+package com.thealgorithms.dynamicprogramming;
+
+/**
+ * Class to find the maximum sum of non-adjacent elements in an array. This
+ * class contains two approaches: one with O(n) space complexity and another
+ * with O(1) space optimization. For more information, refer to
+ * https://takeuforward.org/data-structure/maximum-sum-of-non-adjacent-elements-dp-5/
+ */
+final class MaximumSumOfNonAdjacentElements {
+
+    private MaximumSumOfNonAdjacentElements() {
+    }
+
+    /**
+     * Approach 1: Uses a dynamic programming array to store the maximum sum at
+     * each index. Time Complexity: O(n) - where n is the length of the input
+     * array. Space Complexity: O(n) - due to the additional dp array.
+     * @param arr The input array of integers.
+     * @return The maximum sum of non-adjacent elements.
+     */
+    public static int getMaxSumApproach1(int[] arr) {
+        if (arr.length == 0) {
+            return 0; // Check for empty array
+        }
+
+        int n = arr.length;
+        int[] dp = new int[n];
+
+        // Base case: Maximum sum if only one element is present.
+        dp[0] = arr[0];
+
+        for (int ind = 1; ind < n; ind++) {
+
+            // Case 1: Do not take the current element, carry forward the previous max
+            // sum.
+            int notTake = dp[ind - 1];
+
+            // Case 2: Take the current element, add it to the max sum up to two
+            // indices before.
+            int take = arr[ind];
+            if (ind > 1) {
+                take += dp[ind - 2];
+            }
+
+            // Store the maximum of both choices in the dp array.
+            dp[ind] = Math.max(take, notTake);
+        }
+
+        return dp[n - 1];
+    }
+
+    /**
+     * Approach 2: Optimized space complexity approach using two variables instead
+     * of an array. Time Complexity: O(n) - where n is the length of the input
+     * array. Space Complexity: O(1) - as it only uses constant space for two
+     * variables.
+     * @param arr The input array of integers.
+     * @return The maximum sum of non-adjacent elements.
+     */
+    public static int getMaxSumApproach2(int[] arr) {
+        if (arr.length == 0) {
+            return 0; // Check for empty array
+        }
+
+        int n = arr.length;
+
+        // Two variables to keep track of previous two results:
+        // prev1 = max sum up to the last element (n-1)
+        // prev2 = max sum up to the element before last (n-2)
+
+        int prev1 = arr[0]; // Base case: Maximum sum for the first element.
+        int prev2 = 0;
+
+        for (int ind = 1; ind < n; ind++) {
+            // Case 1: Do not take the current element, keep the last max sum.
+            int notTake = prev1;
+
+            // Case 2: Take the current element and add it to the result from two
+            // steps back.
+            int take = arr[ind];
+            if (ind > 1) {
+                take += prev2;
+            }
+
+            // Calculate the current maximum sum and update previous values.
+            int current = Math.max(take, notTake);
+
+            // Shift prev1 and prev2 for the next iteration.
+            prev2 = prev1;
+            prev1 = current;
+        }
+
+        return prev1;
+    }
+}

src/main/java/com/thealgorithms/dynamicprogramming/NewManShanksPrime.java

@@ -1,25 +1,48 @@
 package com.thealgorithms.dynamicprogramming;
 
 /**
+ * The NewManShanksPrime class provides a method to determine whether the nth
+ * New Man Shanks prime matches an expected answer.
+ *
+ * <p>This is based on the New Man Shanks prime sequence defined by the recurrence
+ * relation:</p>
+ *
+ * <pre>
+ * a(n) = 2 * a(n-1) + a(n-2) for n >= 2
+ * a(0) = 1
+ * a(1) = 1
+ * </pre>
+ *
+ * <p>For more information on New Man Shanks primes, please refer to the
+ * <a href="https://en.wikipedia.org/wiki/Newman%E2%80%93Shanks%E2%80%93Williams_prime">
+ * Wikipedia article</a>.</p>
+ *
+ * <p>Note: The class is designed to be non-instantiable.</p>
+ *
  * @author <a href="https://github.com/siddhant2002">Siddhant Swarup Mallick</a>
- * Program description - To find the New Man Shanks Prime.
- * <a href="https://en.wikipedia.org/wiki/Newman%E2%80%93Shanks%E2%80%93Williams_prime">Wikipedia</a>
  */
 public final class NewManShanksPrime {
     private NewManShanksPrime() {
     }
 
+    /**
+     * Calculates the nth New Man Shanks prime and checks if it equals the
+     * expected answer.
+     *
+     * @param n the index of the New Man Shanks prime to calculate (0-based).
+     * @param expectedAnswer the expected value of the nth New Man Shanks prime.
+     * @return true if the calculated nth New Man Shanks prime matches the
+     *         expected answer; false otherwise.
+     */
     public static boolean nthManShanksPrime(int n, int expectedAnswer) {
         int[] a = new int[n + 1];
-        // array of n+1 size is initialized
         a[0] = 1;
         a[1] = 1;
-        // The 0th and 1st index position values are fixed. They are initialized as 1
+
         for (int i = 2; i <= n; i++) {
             a[i] = 2 * a[i - 1] + a[i - 2];
         }
-        // The loop is continued till n
+
         return a[n] == expectedAnswer;
-        // returns true if calculated answer matches with expected answer
     }
 }

src/main/java/com/thealgorithms/dynamicprogramming/RodCutting.java

@@ -15,9 +15,13 @@ private RodCutting() {
      * @param price An array representing the prices of different pieces, where price[i-1]
      *              represents the price of a piece of length i.
      * @param n     The length of the rod to be cut.
+     * @throws IllegalArgumentException if the price array is null or empty, or if n is less than 0.
      * @return The maximum obtainable value.
      */
     public static int cutRod(int[] price, int n) {
+        if (price == null || price.length == 0) {
+            throw new IllegalArgumentException("Price array cannot be null or empty.");
+        }
         // Create an array to store the maximum obtainable values for each rod length.
         int[] val = new int[n + 1];
         val[0] = 0;

src/main/java/com/thealgorithms/dynamicprogramming/WineProblem.java

@@ -1,21 +1,40 @@
 package com.thealgorithms.dynamicprogramming;
 
 /**
- * Imagine you have a collection of N wines placed next to each other on the
- * shelf. The price of ith wine is pi(Prices of different wines are different).
- * Because wine gets better every year supposing today is year 1, on year y the
- * price would be y*pi i.e y times the value of the initial year. You want to
- * sell all wines but you have to sell one wine per year. One more constraint on
- * each year you are allowed to sell either leftmost or rightmost wine on the
- * shelf. You are not allowed to reorder. You have to find the maximum profit
+ * The WineProblem class provides a solution to the wine selling problem.
+ * Given a collection of N wines with different prices, the objective is to maximize profit by selling
+ * one wine each year, considering the constraint that only the leftmost or rightmost wine can be sold
+ * at any given time.
  *
+ * The price of the ith wine is pi, and the selling price increases by a factor of the year in which
+ * it is sold. This class implements three approaches to solve the problem:
+ *
+ * 1. **Recursion**: A straightforward recursive method that computes the maximum profit.
+ *    - Time Complexity: O(2^N)
+ *    - Space Complexity: O(N) due to recursive calls.
+ *
+ * 2. **Top-Down Dynamic Programming (Memoization)**: This approach caches the results of subproblems
+ *    to avoid redundant computations.
+ *    - Time Complexity: O(N^2)
+ *    - Space Complexity: O(N^2) for the storage of results and O(N) for recursion stack.
+ *
+ * 3. **Bottom-Up Dynamic Programming (Tabulation)**: This method builds a table iteratively to
+ *    compute the maximum profit for all possible subproblems.
+ *    - Time Complexity: O(N^2)
+ *    - Space Complexity: O(N^2) for the table.
  */
 public final class WineProblem {
     private WineProblem() {
     }
 
-    // Method 1: Using Recursion
-    // Time Complexity=0(2^N) Space Complexity=Recursion extra space
+    /**
+     * Calculate maximum profit using recursion.
+     *
+     * @param arr Array of wine prices.
+     * @param si  Start index of the wine to consider.
+     * @param ei  End index of the wine to consider.
+     * @return Maximum profit obtainable by selling the wines.
+     */
     public static int wpRecursion(int[] arr, int si, int ei) {
         int n = arr.length;
         int year = (n - (ei - si + 1)) + 1;
@@ -29,8 +48,15 @@ public static int wpRecursion(int[] arr, int si, int ei) {
         return Math.max(start, end);
     }
 
-    // Method 2: Top-Down DP(Memoization)
-    // Time Complexity=0(N*N) Space Complexity=0(N*N)+Recursion extra space
+    /**
+     * Calculate maximum profit using top-down dynamic programming with memoization.
+     *
+     * @param arr  Array of wine prices.
+     * @param si   Start index of the wine to consider.
+     * @param ei   End index of the wine to consider.
+     * @param strg 2D array to store results of subproblems.
+     * @return Maximum profit obtainable by selling the wines.
+     */
     public static int wptd(int[] arr, int si, int ei, int[][] strg) {
         int n = arr.length;
         int year = (n - (ei - si + 1)) + 1;
@@ -45,15 +71,22 @@ public static int wptd(int[] arr, int si, int ei, int[][] strg) {
         int end = wptd(arr, si, ei - 1, strg) + arr[ei] * year;
 
         int ans = Math.max(start, end);
-
         strg[si][ei] = ans;
 
         return ans;
     }
 
-    // Method 3: Bottom-Up DP(Tabulation)
-    // Time Complexity=0(N*N/2)->0(N*N) Space Complexity=0(N*N)
+    /**
+     * Calculate maximum profit using bottom-up dynamic programming with tabulation.
+     *
+     * @param arr Array of wine prices.
+     * @throws IllegalArgumentException if the input array is null or empty.
+     * @return Maximum profit obtainable by selling the wines.
+     */
     public static int wpbu(int[] arr) {
+        if (arr == null || arr.length == 0) {
+            throw new IllegalArgumentException("Input array cannot be null or empty.");
+        }
         int n = arr.length;
         int[][] strg = new int[n][n];
 
@@ -73,13 +106,4 @@ public static int wpbu(int[] arr) {
         }
         return strg[0][n - 1];
     }
-
-    public static void main(String[] args) {
-        int[] arr = {2, 3, 5, 1, 4};
-        System.out.println("Method 1: " + wpRecursion(arr, 0, arr.length - 1));
-        System.out.println("Method 2: " + wptd(arr, 0, arr.length - 1, new int[arr.length][arr.length]));
-        System.out.println("Method 3: " + wpbu(arr));
-    }
 }
-// Memoization vs Tabulation : https://www.geeksforgeeks.org/tabulation-vs-memoization/
-// Question Link : https://www.geeksforgeeks.org/maximum-profit-sale-wines/

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

@@ -1,10 +1,6 @@
 package com.thealgorithms.searches;
 
 import com.thealgorithms.devutils.searches.SearchAlgorithm;
-import java.util.Arrays;
-import java.util.Random;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.stream.IntStream;
 
 /**
  * Binary search is one of the most popular algorithms The algorithm finds the
@@ -57,26 +53,4 @@ private <T extends Comparable<T>> int search(T[] array, T key, int left, int rig
             return search(array, key, median + 1, right);
         }
     }
-
-    // Driver Program
-    public static void main(String[] args) {
-        // Just generate data
-        Random r = ThreadLocalRandom.current();
-
-        int size = 100;
-        int maxElement = 100000;
-
-        Integer[] integers = IntStream.generate(() -> r.nextInt(maxElement)).limit(size).sorted().boxed().toArray(Integer[] ::new);
-
-        // The element that should be found
-        int shouldBeFound = integers[r.nextInt(size - 1)];
-
-        BinarySearch search = new BinarySearch();
-        int atIndex = search.find(integers, shouldBeFound);
-
-        System.out.printf("Should be found: %d. Found %d at index %d. An array length %d%n", shouldBeFound, integers[atIndex], atIndex, size);
-
-        int toCheck = Arrays.binarySearch(integers, shouldBeFound);
-        System.out.printf("Found by system method at an index: %d. Is equal: %b%n", toCheck, toCheck == atIndex);
-    }
 }