Merge branch 'master' into master-3

Author: RANJEETJ06

DIRECTORY.md

@@ -608,6 +608,7 @@
             * [EggDroppingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/EggDroppingTest.java)
             * [KnapsackMemoizationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/KnapsackMemoizationTest.java)
             * [LevenshteinDistanceTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/LevenshteinDistanceTests.java)
+            * [MinimumPathSumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/MinimumPathSumTest.java)
             * [OptimalJobSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/OptimalJobSchedulingTest.java)
             * [PartitionProblemTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/PartitionProblemTest.java)
             * [SubsetCountTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/dynamicprogramming/SubsetCountTest.java)
@@ -637,6 +638,7 @@
             * [FactorialTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FactorialTest.java)
             * [FastInverseSqrtTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FastInverseSqrtTests.java)
             * [FFTTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FFTTest.java)
+            * [FibonacciJavaStreamsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciJavaStreamsTest.java)
             * [FibonacciNumberCheckTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciNumberCheckTest.java)
             * [FindMaxTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FindMaxTest.java)
             * [FindMinTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FindMinTest.java)
@@ -673,6 +675,7 @@
             * [SquareRootWithNewtonRaphsonTestMethod](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SquareRootWithNewtonRaphsonTestMethod.java)
             * [StandardDeviationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/StandardDeviationTest.java)
             * [StandardScoreTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/StandardScoreTest.java)
+            * [SumOfArithmeticSeriesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SumOfArithmeticSeriesTest.java)
             * [SumOfDigitsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SumOfDigitsTest.java)
             * [SumWithoutArithmeticOperatorsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SumWithoutArithmeticOperatorsTest.java)
             * [TestArmstrong](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/TestArmstrong.java)
@@ -701,6 +704,7 @@
             * [NextFitTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/NextFitTest.java)
             * [PasswordGenTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/PasswordGenTest.java)
             * [SieveOfEratosthenesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/SieveOfEratosthenesTest.java)
+            * [StackPostfixNotationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/StackPostfixNotationTest.java)
             * [TestPrintMatrixInSpiralOrder](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TestPrintMatrixInSpiralOrder.java)
             * [TwoPointersTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/TwoPointersTest.java)
             * [UniquePathsTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/others/UniquePathsTests.java)

pom.xml

@@ -45,6 +45,11 @@
             <version>5.9.0</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.12.0</version>
+        </dependency>
     </dependencies>
 
     <build>

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

@@ -1,81 +1,69 @@
 package com.thealgorithms.maths;
 
+import java.util.LinkedHashSet;
+import java.util.Set;
+import org.apache.commons.lang3.tuple.Pair;
+
 /**
- * Amicable numbers are two different numbers so related that the sum of the
- * proper divisors of each is equal to the other number. (A proper divisor of a
- * number is a positive factor of that number other than the number itself. For
- * example, the proper divisors of 6 are 1, 2, and 3.) A pair of amicable
- * numbers constitutes an aliquot sequence of period 2. It is unknown if there
- * are infinitely many pairs of amicable numbers. *
+ * Amicable numbers are two different natural numbers that the sum of the
+ * proper divisors of each is equal to the other number.
+ * (A proper divisor of a number is a positive factor of that number other than the number itself.
+ * For example, the proper divisors of 6 are 1, 2, and 3.)
+ * A pair of amicable numbers constitutes an aliquot sequence of period 2.
+ * It is unknown if there are infinitely many pairs of amicable numbers.
  *
  * <p>
- * link: https://en.wikipedia.org/wiki/Amicable_numbers *
- *
+ * link: https://en.wikipedia.org/wiki/Amicable_numbers
  * <p>
- * Simple Example : (220,284) 220 is divisible by {1,2,4,5,10,11,20,22,44,55,110
- * } <- Sum = 284
- * 284 is divisible by -> 1,2,4,71,142 and the Sum of that is. Yes right you
- * probably expected it 220
+ * Simple Example : (220, 284)
+ * 220 is divisible by {1,2,4,5,10,11,20,22,44,55,110} <- SUM = 284
+ * 284 is divisible by {1,2,4,71,142} <- SUM = 220.
  */
 public class AmicableNumber {
-
-    public static void main(String[] args) {
-        AmicableNumber.findAllInRange(1, 3000);
-        /* Res -> Int Range of 1 till 3000there are 3Amicable_numbers These are  1: = ( 220,284)
-    2: = ( 1184,1210) 3: = ( 2620,2924) So it worked	*/
-    }
-
     /**
-     * @param startValue
-     * @param stopValue
-     * @return
+     * Finds all the amicable numbers in a given range.
+     *
+     * @param from range start value
+     * @param to   range end value (inclusive)
+     * @return list with amicable numbers found in given range.
      */
-    static void findAllInRange(int startValue, int stopValue) {
-        /* the 2 for loops are to avoid to double check tuple. For example (200,100) and (100,200)
-         * is the same calculation also to avoid is to check the number with it self. a number with
-         * itself is always a AmicableNumber
-         * */
-        StringBuilder res = new StringBuilder();
-        int countofRes = 0;
+    public static Set<Pair<Integer, Integer>> findAllInRange(int from, int to) {
+        if (from <= 0 || to <= 0 || to < from) {
+            throw new IllegalArgumentException("Given range of values is invalid!");
+        }
+
+        Set<Pair<Integer, Integer>> result = new LinkedHashSet<>();
 
-        for (int i = startValue; i < stopValue; i++) {
-            for (int j = i + 1; j <= stopValue; j++) {
+        for (int i = from; i < to; i++) {
+            for (int j = i + 1; j <= to; j++) {
                 if (isAmicableNumber(i, j)) {
-                    countofRes++;
-                    res.append("" + countofRes + ": = ( " + i + "," + j + ")"
-                        + "\t");
+                    result.add(Pair.of(i, j));
                 }
             }
         }
-        res.insert(0, "Int Range of " + startValue + " till " + stopValue + " there are " + countofRes + " Amicable_numbers.These are \n ");
-        System.out.println(res);
+        return result;
     }
 
     /**
-     * Check if {@code numberOne and numberTwo } are AmicableNumbers or not
-     *
-     * @param numberOne numberTwo
-     * @return {@code true} if {@code numberOne numberTwo} isAmicableNumbers
-     * otherwise false
+     * Checks whether 2 numbers are AmicableNumbers or not.
      */
-    static boolean isAmicableNumber(int numberOne, int numberTwo) {
-        return ((recursiveCalcOfDividerSum(numberOne, numberOne) == numberTwo && numberOne == recursiveCalcOfDividerSum(numberTwo, numberTwo)));
+    public static boolean isAmicableNumber(int a, int b) {
+        if (a <= 0 || b <= 0) {
+            throw new IllegalArgumentException("Input numbers must be natural!");
+        }
+        return sumOfDividers(a, a) == b && sumOfDividers(b, b) == a;
     }
 
     /**
-     * calculated in recursive calls the Sum of all the Dividers beside it self
-     *
-     * @param number div = the next to test dividely by using the modulo
-     * operator
-     * @return sum of all the dividers
+     * Recursively calculates the sum of all dividers for a given number excluding the divider itself.
      */
-    static int recursiveCalcOfDividerSum(int number, int div) {
-        if (div == 1) {
+    private static int sumOfDividers(int number, int divisor) {
+        if (divisor == 1) {
             return 0;
-        } else if (number % --div == 0) {
-            return recursiveCalcOfDividerSum(number, div) + div;
+        } else if (number % --divisor == 0) {
+            return sumOfDividers(number, divisor) + divisor;
         } else {
-            return recursiveCalcOfDividerSum(number, div);
+            return sumOfDividers(number, divisor);
         }
     }
 }

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

@@ -2,7 +2,6 @@
 
 import java.math.BigDecimal;
 import java.util.List;
-import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Stream;
 
@@ -14,7 +13,7 @@ public class FibonacciJavaStreams {
 
     public static Optional<BigDecimal> calculate(final BigDecimal index) {
         if (index == null || index.compareTo(BigDecimal.ZERO) < 0) {
-            return Optional.empty();
+            throw new IllegalArgumentException("Input index cannot be null or negative!");
         }
 
         if (index.compareTo(BigDecimal.ONE) < 0) {
@@ -30,72 +29,4 @@ public static Optional<BigDecimal> calculate(final BigDecimal index) {
 
         return results.isEmpty() ? Optional.empty() : Optional.of(results.get(results.size() - 1));
     }
-
-    public static void assertThat(final Object actual, final Object expected) {
-        if (!Objects.equals(actual, expected)) {
-            throw new AssertionError(String.format("expected=%s but was actual=%s", expected, actual));
-        }
-    }
-
-    public static void main(final String[] args) {
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(-1));
-            assertThat(result.isEmpty(), true);
-        }
-        {
-            final Optional<BigDecimal> result = calculate(BigDecimal.ZERO);
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, BigDecimal.ZERO));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(BigDecimal.ONE);
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, BigDecimal.ONE));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(2));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, BigDecimal.ONE));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(3));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, new BigDecimal(2)));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(10));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, new BigDecimal(55)));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(20));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, new BigDecimal(6765)));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(30));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, new BigDecimal(832040)));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(40));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, new BigDecimal(102334155)));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(50));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, new BigDecimal(12586269025L)));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(100));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, new BigDecimal("354224848179261915075")));
-        }
-        {
-            final Optional<BigDecimal> result = calculate(new BigDecimal(200));
-            assertThat(result.isPresent(), true);
-            result.ifPresent(value -> assertThat(value, new BigDecimal("280571172992510140037611932413038677189525")));
-        }
-    }
 }

src/main/java/com/thealgorithms/others/StackPostfixNotation.java

@@ -1,25 +1,24 @@
 package com.thealgorithms.others;
 
-import java.util.*;
+import java.util.Scanner;
+import java.util.Stack;
 
-public class StackPostfixNotation {
-
-    public static void main(String[] args) {
-        Scanner scanner = new Scanner(System.in);
-        String post = scanner.nextLine(); // Takes input with spaces in between eg. "1 21 +"
-        System.out.println(postfixEvaluate(post));
-        scanner.close();
+public final class StackPostfixNotation {
+    private StackPostfixNotation() {
     }
 
     // Evaluates the given postfix expression string and returns the result.
-    public static int postfixEvaluate(String exp) {
+    public static int postfixEvaluate(final String exp) {
         Stack<Integer> s = new Stack<Integer>();
         Scanner tokens = new Scanner(exp);
 
         while (tokens.hasNext()) {
             if (tokens.hasNextInt()) {
                 s.push(tokens.nextInt()); // If int then push to stack
             } else { // else pop top two values and perform the operation
+                if (s.size() < 2) {
+                    throw new IllegalArgumentException("exp is not a proper postfix expression (too few arguments).");
+                }
                 int num2 = s.pop();
                 int num1 = s.pop();
                 String op = tokens.next();
@@ -28,12 +27,16 @@ public static int postfixEvaluate(String exp) {
                     case "+" -> s.push(num1 + num2);
                     case "-" -> s.push(num1 - num2);
                     case "*" -> s.push(num1 * num2);
-                    default -> s.push(num1 / num2);
+                    case "/" -> s.push(num1 / num2);
+                    default -> throw new IllegalArgumentException("exp contains an unknown operation.");
                 }
                 //  "+", "-", "*", "/"
             }
         }
         tokens.close();
+        if (s.size() != 1) {
+            throw new IllegalArgumentException("exp is not a proper postfix expression.");
+        }
         return s.pop();
     }
 }

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

@@ -2,14 +2,57 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Set;
+import org.apache.commons.lang3.tuple.Pair;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 public class AmicableNumberTest {
+    private static final String INVALID_RANGE_EXCEPTION_MESSAGE = "Given range of values is invalid!";
+    private static final String INVALID_NUMBERS_EXCEPTION_MESSAGE = "Input numbers must be natural!";
 
     @Test
-    void testAmicableNumber() {
+    public void testShouldThrowExceptionWhenInvalidRangeProvided() {
+        checkInvalidRange(0, 0);
+        checkInvalidRange(0, 1);
+        checkInvalidRange(1, 0);
+        checkInvalidRange(10, -1);
+        checkInvalidRange(-1, 10);
+    }
+
+    @Test
+    public void testShouldThrowExceptionWhenInvalidNumbersProvided() {
+        checkInvalidNumbers(0, 0);
+        checkInvalidNumbers(0, 1);
+        checkInvalidNumbers(1, 0);
+    }
+
+    @Test
+    public void testAmicableNumbers() {
         assertThat(AmicableNumber.isAmicableNumber(220, 284)).isTrue();
         assertThat(AmicableNumber.isAmicableNumber(1184, 1210)).isTrue();
         assertThat(AmicableNumber.isAmicableNumber(2620, 2924)).isTrue();
     }
+
+    @Test
+    public void testShouldFindAllAmicableNumbersInRange() {
+        // given
+        var expectedResult = Set.of(Pair.of(220, 284), Pair.of(1184, 1210), Pair.of(2620, 2924));
+
+        // when
+        Set<Pair<Integer, Integer>> result = AmicableNumber.findAllInRange(1, 3000);
+
+        // then
+        Assertions.assertTrue(result.containsAll(expectedResult));
+    }
+
+    private static void checkInvalidRange(int from, int to) {
+        IllegalArgumentException exception = Assertions.assertThrows(IllegalArgumentException.class, () -> AmicableNumber.findAllInRange(from, to));
+        Assertions.assertEquals(exception.getMessage(), INVALID_RANGE_EXCEPTION_MESSAGE);
+    }
+
+    private static void checkInvalidNumbers(int a, int b) {
+        IllegalArgumentException exception = Assertions.assertThrows(IllegalArgumentException.class, () -> AmicableNumber.isAmicableNumber(a, b));
+        Assertions.assertEquals(exception.getMessage(), INVALID_NUMBERS_EXCEPTION_MESSAGE);
+    }
 }