Add top-down / down-top approaches examples (for Fibonacci task)

Author: andrei-punko

src/main/java/by/andd3dfx/numeric/Fibonacci.java

@@ -3,20 +3,39 @@
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * Check this article for comparison of top-down / down-top approaches:
+ * https://habr.com/ru/post/423939/
+ */
 public class Fibonacci {
 
-    private static final Map<Integer, Long> map = new HashMap<Integer, Long>() {{
+    private static final Map<Integer, Long> map = new HashMap<>() {{
+        put(0, 0L);
         put(1, 1L);
-        put(2, 1L);
     }};
 
-    public static long get(int n) {
-        if (n < 1) throw new IllegalArgumentException("Number should be greater than 0!");
+    /**
+     * Top-down approach (recursive, better)
+     */
+    public static long calculate(int n) {
+        if (n < 0) throw new IllegalArgumentException("Number should be not less than 0!");
 
         if (!map.containsKey(n)) {
-            map.put(n, get(n - 1) + get(n - 2));
+            map.put(n, calculate(n - 1) + calculate(n - 2));
         }
 
         return map.get(n);
     }
+
+    /**
+     * Down-top approach (just as example)
+     */
+    public static long calculate2(int n) {
+        if (n < 0) throw new IllegalArgumentException("Number should be not less than 0!");
+
+        for (int i = 2; i <= n; i++) {
+            map.put(n, map.get(n - 1) + map.get(n - 2));
+        }
+        return map.get(n);
+    }
 }

src/test/java/by/andd3dfx/numeric/FibonacciTest.java

@@ -6,35 +6,58 @@
 
 import org.junit.Test;
 
+import java.util.function.Function;
+
 public class FibonacciTest {
 
   @Test
-  public void get() {
-    assertThat("Expected F(2) = 1", Fibonacci.get(2), is(1L));
-    assertThat("Expected F(4) = 3", Fibonacci.get(4), is(3L));
-    assertThat("Expected F(1) = 1", Fibonacci.get(1), is(1L));
-    assertThat("Expected F(8) = 21", Fibonacci.get(8), is(21L));
-    assertThat("Expected F(9) = 34", Fibonacci.get(9), is(34L));
-    assertThat("Expected F(3) = 2", Fibonacci.get(3), is(2L));
-    assertThat("Expected F(7) = 13", Fibonacci.get(7), is(13L));
-    assertThat("Expected F(10) = 55", Fibonacci.get(10), is(55L));
-    assertThat("Expected F(6) = 8", Fibonacci.get(6), is(8L));
-    assertThat("Expected F(5) = 5", Fibonacci.get(5), is(5L));
+  public void calculate() {
+    assertThat("Expected F(2) = 1", Fibonacci.calculate(2), is(1L));
+    assertThat("Expected F(4) = 3", Fibonacci.calculate(4), is(3L));
+    assertThat("Expected F(1) = 1", Fibonacci.calculate(1), is(1L));
+    assertThat("Expected F(0) = 0", Fibonacci.calculate(0), is(0L));
+    assertThat("Expected F(8) = 21", Fibonacci.calculate(8), is(21L));
+    assertThat("Expected F(9) = 34", Fibonacci.calculate(9), is(34L));
+    assertThat("Expected F(3) = 2", Fibonacci.calculate(3), is(2L));
+    assertThat("Expected F(7) = 13", Fibonacci.calculate(7), is(13L));
+    assertThat("Expected F(10) = 55", Fibonacci.calculate(10), is(55L));
+    assertThat("Expected F(6) = 8", Fibonacci.calculate(6), is(8L));
+    assertThat("Expected F(5) = 5", Fibonacci.calculate(5), is(5L));
+  }
+
+  @Test
+  public void calculate2() {
+    assertThat("Expected F(2) = 1", Fibonacci.calculate2(2), is(1L));
+    assertThat("Expected F(4) = 3", Fibonacci.calculate2(4), is(3L));
+    assertThat("Expected F(1) = 1", Fibonacci.calculate2(1), is(1L));
+    assertThat("Expected F(0) = 0", Fibonacci.calculate2(0), is(0L));
+    assertThat("Expected F(8) = 21", Fibonacci.calculate2(8), is(21L));
+    assertThat("Expected F(9) = 34", Fibonacci.calculate2(9), is(34L));
+    assertThat("Expected F(3) = 2", Fibonacci.calculate2(3), is(2L));
+    assertThat("Expected F(7) = 13", Fibonacci.calculate2(7), is(13L));
+    assertThat("Expected F(10) = 55", Fibonacci.calculate2(10), is(55L));
+    assertThat("Expected F(6) = 8", Fibonacci.calculate2(6), is(8L));
+    assertThat("Expected F(5) = 5", Fibonacci.calculate2(5), is(5L));
+  }
+
+  @Test
+  public void calculateForWrongParam() {
+    checkIsExceptionThrown(Fibonacci::calculate, -1);
+    checkIsExceptionThrown(Fibonacci::calculate, -10);
   }
 
   @Test
-  public void getForWrongParam() {
-    checkIsExceptionThrown(0);
-    checkIsExceptionThrown(-1);
-    checkIsExceptionThrown(-10);
+  public void calculate2ForWrongParam() {
+    checkIsExceptionThrown(Fibonacci::calculate2, -1);
+    checkIsExceptionThrown(Fibonacci::calculate2, -10);
   }
 
-  private void checkIsExceptionThrown(int n) {
+  private void checkIsExceptionThrown(Function<Integer, Long> function, int n) {
     try {
-      Fibonacci.get(n);
+      function.apply(n);
       fail("Exception should be thrown");
     } catch (IllegalArgumentException iae) {
-      assertThat("Wrong message", iae.getMessage(), is("Number should be greater than 0!"));
+      assertThat("Wrong message", iae.getMessage(), is("Number should be not less than 0!"));
     }
   }
 }