LeetCode problem: 509. Fibonacci Number

Author: borrelunde

src/main/java/com/bl/fibonacci_number/README.md

@@ -0,0 +1,42 @@
+# 509. Fibonacci Number
+
+Difficulty: `Easy`  
+Topics: `Math`, `Dynamic Programming`, `Recursion`, `Memoization`
+
+The **Fibonacci numbers**, commonly denoted `F(n)` form a sequence, called the **Fibonacci sequence**, such that each
+number is the sum of the two preceding ones, starting from `0` and `1`. That is,
+
+```text
+F(0) = 0, F(1) = 1  
+F(n) = F(n - 1) + F(n - 2), for n > 1.
+```
+
+Given `n`, calculate `F(n)`.
+
+**Example 1:**
+
+```text
+Input: n = 2
+Output: 1
+Explanation: F(2) = F(1) + F(0) = 1 + 0 = 1.
+```
+
+**Example 2:**
+
+```text
+Input: n = 3
+Output: 2
+Explanation: F(3) = F(2) + F(1) = 1 + 1 = 2.
+```
+
+**Example 3:**
+
+```text
+Input: n = 4
+Output: 3
+Explanation: F(4) = F(3) + F(2) = 2 + 1 = 3.
+```
+
+**Constraints:**
+
+- `0 <= n <= 30`

src/main/java/com/bl/fibonacci_number/Solution.java

@@ -0,0 +1,59 @@
+package com.bl.fibonacci_number;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This is the solution to the LeetCode problem: 509. Fibonacci Number
+ *
+ * @author Børre A. Opedal Lunde
+ * @since 2024.01.27
+ */
+public class Solution {
+
+	// The cache of Fibonacci numbers.
+	private static final List<Integer> FIBONACCI_NUMBERS_CACHE = new ArrayList<>();
+
+	// Initialize the cache with the two first Fibonacci numbers.
+	static {
+		FIBONACCI_NUMBERS_CACHE.add(0);
+		FIBONACCI_NUMBERS_CACHE.add(1);
+	}
+
+	public int fib(int n) {
+
+		final int fibonacciNumber;
+		final int lastCachedFibonacciNumberIndex = FIBONACCI_NUMBERS_CACHE.size() - 1;
+
+		// Check if the Fibonacci number is already cached.
+		if (n <= lastCachedFibonacciNumberIndex) {
+
+			// Retrieve the Fibonacci number from the cache.
+			fibonacciNumber = FIBONACCI_NUMBERS_CACHE.get(n);
+
+			// Return the Fibonacci number.
+			return fibonacciNumber;
+		}
+
+		// If the Fibonacci number is not in the cache, let's start from where
+		// we left off and put it there.
+
+		// Retrieve the two last Fibonacci numbers from the cache.
+		final int a = FIBONACCI_NUMBERS_CACHE.get(lastCachedFibonacciNumberIndex - 1);
+		final int b = FIBONACCI_NUMBERS_CACHE.get(lastCachedFibonacciNumberIndex);
+
+		// Calculate the Fibonacci number.
+		fibonacciNumber = a + b;
+
+		// Add the Fibonacci number to the cache.
+		FIBONACCI_NUMBERS_CACHE.add(fibonacciNumber);
+
+		// Check if we have reached the Fibonacci number we are looking for.
+		if (n - 1 == lastCachedFibonacciNumberIndex) {
+			return fibonacciNumber;
+		}
+
+		// If not, let's continue recursively until we reach it.
+		return fib(n);
+	}
+}

src/test/java/com/bl/fibonacci_number/SolutionTest.java

@@ -0,0 +1,96 @@
+package com.bl.fibonacci_number;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * This is the test to the LeetCode problem: 509. Fibonacci Number
+ *
+ * @author Børre A. Opedal Lunde
+ * @since 2024.01.27
+ */
+@DisplayName("Fibonacci Number")
+class SolutionTest {
+
+	final Solution solution = new Solution();
+
+	@Test
+	@DisplayName("Example one")
+	void exampleOne() {
+		int n = 2;
+		int expected = 1;
+		int actual = solution.fib(n);
+		assertEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Example two")
+	void exampleTwo() {
+		int n = 3;
+		int expected = 2;
+		int actual = solution.fib(n);
+		assertEquals(expected, actual);
+	}
+
+	@Test
+	@DisplayName("Example three")
+	void exampleThree() {
+		int n = 4;
+		int expected = 3;
+		int actual = solution.fib(n);
+		assertEquals(expected, actual);
+	}
+
+	static Stream<Arguments> provideFibonacciNumbersFromZeroToThirty() {
+		return Stream.of(
+				Arguments.of(0, 0),
+				Arguments.of(1, 1),
+				Arguments.of(2, 1),
+				Arguments.of(3, 2),
+				Arguments.of(4, 3),
+				Arguments.of(5, 5),
+				Arguments.of(6, 8),
+				Arguments.of(7, 13),
+				Arguments.of(8, 21),
+				Arguments.of(9, 34),
+				Arguments.of(10, 55),
+				Arguments.of(11, 89),
+				Arguments.of(12, 144),
+				Arguments.of(13, 233),
+				Arguments.of(14, 377),
+				Arguments.of(15, 610),
+				Arguments.of(16, 987),
+				Arguments.of(17, 1597),
+				Arguments.of(18, 2584),
+				Arguments.of(19, 4181),
+				Arguments.of(20, 6765),
+				Arguments.of(21, 10946),
+				Arguments.of(22, 17711),
+				Arguments.of(23, 28657),
+				Arguments.of(24, 46368),
+				Arguments.of(25, 75025),
+				Arguments.of(26, 121393),
+				Arguments.of(27, 196418),
+				Arguments.of(28, 317811),
+				Arguments.of(29, 514229),
+				Arguments.of(30, 832040)
+				// Stop at 30 because the problem description
+				// uses that as its upper limit.
+		);
+	}
+
+	@ParameterizedTest(name = "n {0} is Fibonacci number {1}")
+	@DisplayName("Fibonacci numbers from zero to thirty")
+	@MethodSource("provideFibonacciNumbersFromZeroToThirty")
+	void fibonacciNumbersFromZeroToThirty(int n, int expected) {
+		int actual = solution.fib(n);
+		assertEquals(expected, actual);
+	}
+}