From 2ee65f70004812c7d385a9a20a4f468f6ef3b79c Mon Sep 17 00:00:00 2001 From: Priya Singh Date: Tue, 1 Oct 2024 18:32:03 +0530 Subject: [PATCH 1/4] Added Resursive implementation to get nth fibonacci number with memoization --- .../maths/FibonacciJavaRecursion.java | 42 +++++++++++++++++++ .../maths/FibonacciJavaRecursionTest.java | 36 ++++++++++++++++ 2 files changed, 78 insertions(+) create mode 100644 src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java create mode 100644 src/test/java/com/thealgorithms/maths/FibonacciJavaRecursionTest.java diff --git a/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java b/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java new file mode 100644 index 000000000000..68b4c59c0b7f --- /dev/null +++ b/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java @@ -0,0 +1,42 @@ +package com.thealgorithms.maths; + +import java.math.BigInteger; +import java.util.HashMap; +import java.util.Map; + +/** + * author : @pri-sin + * This class provides methods for calculating Fibonacci numbers Recursion. + */ +public final class FibonacciJavaRecursion { + static Map fibonacciMap=new HashMap<>(); + + private FibonacciJavaRecursion() { + // Private constructor to prevent instantiation of this utility class. + } + + /** + * Calculates the nth Fibonacci number. + * + * @param n The index of the Fibonacci number to calculate. + * @return The nth Fibonacci number as a BigInteger. + * @throws IllegalArgumentException if the input 'n' is a negative integer. + */ + public static BigInteger computeRecursively(final int n) { + if (n < 0) { + throw new IllegalArgumentException("Input 'n' must be a non-negative integer."); + } + + if (n <= 1) { + fibonacciMap.put(n, BigInteger.valueOf(n)); + return BigInteger.valueOf(n); + } + + if(!fibonacciMap.containsKey(n)) { + fibonacciMap.put(n, computeRecursively(n-2).add(computeRecursively(n-1))); + } + + return fibonacciMap.get(n); + } + +} diff --git a/src/test/java/com/thealgorithms/maths/FibonacciJavaRecursionTest.java b/src/test/java/com/thealgorithms/maths/FibonacciJavaRecursionTest.java new file mode 100644 index 000000000000..7d5fc0f3dca3 --- /dev/null +++ b/src/test/java/com/thealgorithms/maths/FibonacciJavaRecursionTest.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 java.math.BigInteger; +import org.junit.jupiter.api.Test; + +public class FibonacciJavaRecursionTest { + @Test + public void checkValueAtZero() { + assertEquals(BigInteger.ZERO, FibonacciJavaRecursion.computeRecursively(0)); + } + + @Test + public void checkValueAtOne() { + assertEquals(BigInteger.ONE, FibonacciJavaRecursion.computeRecursively(1)); + } + + @Test + public void checkValueAtTwo() { + assertEquals(BigInteger.ONE, FibonacciJavaRecursion.computeRecursively(2)); + } + + @Test + public void checkRecurrenceRelation() { + for (int i = 0; i < 100; ++i) { + assertEquals(FibonacciJavaRecursion.computeRecursively(i + 2), FibonacciJavaRecursion.computeRecursively(i + 1).add(FibonacciJavaRecursion.computeRecursively(i))); + } + } + + @Test + public void checkNegativeInput() { + assertThrows(IllegalArgumentException.class, () -> { FibonacciJavaRecursion.computeRecursively(-1); }); + } +} From 31bb829eecfbf98c3f92e4e309b42338dcb9147e Mon Sep 17 00:00:00 2001 From: Priya Singh Date: Tue, 1 Oct 2024 18:36:03 +0530 Subject: [PATCH 2/4] Added Resursive implementation to get nth fibonacci number with memoization --- .../java/com/thealgorithms/maths/FibonacciJavaRecursion.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java b/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java index 68b4c59c0b7f..9d1ea184c4c3 100644 --- a/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java +++ b/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java @@ -6,7 +6,7 @@ /** * author : @pri-sin - * This class provides methods for calculating Fibonacci numbers Recursion. + * This class provides methods for calculating Fibonacci numbers using Recursion with Memoization. */ public final class FibonacciJavaRecursion { static Map fibonacciMap=new HashMap<>(); From 953f9d8404c572852205897b94bbdbed6f3fead9 Mon Sep 17 00:00:00 2001 From: pri-sin Date: Wed, 2 Oct 2024 15:56:13 +0530 Subject: [PATCH 3/4] Update src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java Co-authored-by: Piotr Idzik <65706193+vil02@users.noreply.github.com> --- .../java/com/thealgorithms/maths/FibonacciJavaRecursion.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java b/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java index 9d1ea184c4c3..e2d83014325f 100644 --- a/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java +++ b/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java @@ -12,7 +12,6 @@ public final class FibonacciJavaRecursion { static Map fibonacciMap=new HashMap<>(); private FibonacciJavaRecursion() { - // Private constructor to prevent instantiation of this utility class. } /** From f25c8d4f5d3e740b789a958529e2f6c72a5da502 Mon Sep 17 00:00:00 2001 From: Priya Singh Date: Wed, 2 Oct 2024 17:11:38 +0530 Subject: [PATCH 4/4] Added Resursive implementation to get nth fibonacci number with memoization --- ...avaRecursion.java => FibonacciWithDP.java} | 24 ++++++------- .../maths/FibonacciJavaRecursionTest.java | 36 ------------------- .../maths/FibonacciWithDPTest.java | 34 ++++++++++++++++++ 3 files changed, 45 insertions(+), 49 deletions(-) rename src/main/java/com/thealgorithms/maths/{FibonacciJavaRecursion.java => FibonacciWithDP.java} (56%) delete mode 100644 src/test/java/com/thealgorithms/maths/FibonacciJavaRecursionTest.java create mode 100644 src/test/java/com/thealgorithms/maths/FibonacciWithDPTest.java diff --git a/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java b/src/main/java/com/thealgorithms/maths/FibonacciWithDP.java similarity index 56% rename from src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java rename to src/main/java/com/thealgorithms/maths/FibonacciWithDP.java index 9d1ea184c4c3..b5fc5d470688 100644 --- a/src/main/java/com/thealgorithms/maths/FibonacciJavaRecursion.java +++ b/src/main/java/com/thealgorithms/maths/FibonacciWithDP.java @@ -1,18 +1,18 @@ package com.thealgorithms.maths; import java.math.BigInteger; -import java.util.HashMap; -import java.util.Map; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; /** * author : @pri-sin * This class provides methods for calculating Fibonacci numbers using Recursion with Memoization. */ -public final class FibonacciJavaRecursion { - static Map fibonacciMap=new HashMap<>(); +public final class FibonacciWithDP { + static List fibonacciList=new ArrayList<>(Arrays.asList(BigInteger.ZERO,BigInteger.ONE)); - private FibonacciJavaRecursion() { - // Private constructor to prevent instantiation of this utility class. + private FibonacciWithDP() { } /** @@ -28,15 +28,13 @@ public static BigInteger computeRecursively(final int n) { } if (n <= 1) { - fibonacciMap.put(n, BigInteger.valueOf(n)); - return BigInteger.valueOf(n); + return fibonacciList.get(n); } - if(!fibonacciMap.containsKey(n)) { - fibonacciMap.put(n, computeRecursively(n-2).add(computeRecursively(n-1))); + if(fibonacciList.size()<=n) { + fibonacciList.add(computeRecursively(n-2).add(computeRecursively(n-1))); } - return fibonacciMap.get(n); - } - + return fibonacciList.get(n); + } } diff --git a/src/test/java/com/thealgorithms/maths/FibonacciJavaRecursionTest.java b/src/test/java/com/thealgorithms/maths/FibonacciJavaRecursionTest.java deleted file mode 100644 index 7d5fc0f3dca3..000000000000 --- a/src/test/java/com/thealgorithms/maths/FibonacciJavaRecursionTest.java +++ /dev/null @@ -1,36 +0,0 @@ -package com.thealgorithms.maths; - -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertThrows; - -import java.math.BigInteger; -import org.junit.jupiter.api.Test; - -public class FibonacciJavaRecursionTest { - @Test - public void checkValueAtZero() { - assertEquals(BigInteger.ZERO, FibonacciJavaRecursion.computeRecursively(0)); - } - - @Test - public void checkValueAtOne() { - assertEquals(BigInteger.ONE, FibonacciJavaRecursion.computeRecursively(1)); - } - - @Test - public void checkValueAtTwo() { - assertEquals(BigInteger.ONE, FibonacciJavaRecursion.computeRecursively(2)); - } - - @Test - public void checkRecurrenceRelation() { - for (int i = 0; i < 100; ++i) { - assertEquals(FibonacciJavaRecursion.computeRecursively(i + 2), FibonacciJavaRecursion.computeRecursively(i + 1).add(FibonacciJavaRecursion.computeRecursively(i))); - } - } - - @Test - public void checkNegativeInput() { - assertThrows(IllegalArgumentException.class, () -> { FibonacciJavaRecursion.computeRecursively(-1); }); - } -} diff --git a/src/test/java/com/thealgorithms/maths/FibonacciWithDPTest.java b/src/test/java/com/thealgorithms/maths/FibonacciWithDPTest.java new file mode 100644 index 000000000000..ed2a8864f8b7 --- /dev/null +++ b/src/test/java/com/thealgorithms/maths/FibonacciWithDPTest.java @@ -0,0 +1,34 @@ +package com.thealgorithms.maths; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import java.math.BigInteger; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +public class FibonacciWithDPTest { + @Test + public void checkValueAtZero() { + assertEquals(BigInteger.ZERO, FibonacciWithDP.computeRecursively(0)); + } + + @ParameterizedTest + @ValueSource(ints = {1, 2}) + public void checkValueAtOneAndTwo(int number) { + assertEquals(BigInteger.ONE, FibonacciWithDP.computeRecursively(number)); + } + + @Test + public void checkRecurrenceRelation() { + for (int i = 0; i < 100; ++i) { + assertEquals(FibonacciWithDP.computeRecursively(i + 2), FibonacciWithDP.computeRecursively(i + 1).add(FibonacciWithDP.computeRecursively(i))); + } + } + + @Test + public void checkNegativeInput() { + assertThrows(IllegalArgumentException.class, () -> { FibonacciWithDP.computeRecursively(-1); }); + } +}