Adjust Factorial and couple of javadocs

Author: andrei-punko

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

@@ -5,21 +5,76 @@
 
 public class Factorial {
 
-    private static Map<Integer, Integer> cache = new HashMap<>();
+    private final static Map<Integer, Integer> cache = new HashMap<>() {{
+        put(0, 1);
+    }};
 
-    static {
-        cache.put(0, 1);
+    /**
+     * Down-top approach
+     */
+    public static int loop(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("n should be >= 0");
+        }
+
+        if (n == 0) {
+            return 1;
+        }
+
+        var result = 1;
+        for (var i = 1; i <= n; i++) {
+            result *= i;
+        }
+        return result;
+    }
+
+    /**
+     * Top-down approach
+     */
+    public static int recursion(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("n should be >= 0");
+        }
+
+        if (n == 0) {
+            return 1;
+        }
+
+        return n * recursion(n - 1);
     }
 
-    public static int calculate(int n) {
-        if (n < 0) throw new IllegalArgumentException("Wrong parameter");
+    /**
+     * Top-down approach
+     */
+    public static int recursionWithCache(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("n should be >= 0");
+        }
 
         if (cache.containsKey(n)) {
             return cache.get(n);
         }
 
-        int result = n * calculate(n - 1);
+        int result = n * recursionWithCache(n - 1);
         cache.put(n, result);
         return result;
     }
+
+    /**
+     * Down-top approach
+     */
+    public static int loopWithCache(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("n should be >= 0");
+        }
+
+        if (cache.containsKey(n)) {
+            return cache.get(n);
+        }
+
+        for (var i = 1; i <= n; i++) {
+            cache.put(i, i * cache.get(i - 1));
+        }
+        return cache.get(n);
+    }
 }

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

@@ -28,7 +28,7 @@ public static int calculate(int n) {
     }
 
     /**
-     * Down-top approach (just as example)
+     * Down-top approach (loop, just as example)
      */
     public static int calculate2(int n) {
         if (n < 0) throw new IllegalArgumentException("Number should be not less than 0!");

src/main/java/by/andd3dfx/string/StringUtil.java

@@ -15,7 +15,7 @@ public static String revert(String string) {
     /**
      * Using the Java language, have the function LetterChanges(str) take the str parameter being passed and modify it
      * using the following algorithm. Replace every letter in the string with the letter following it in the alphabet
-     * (ie. c becomes d, z becomes a). Then capitalize every vowel in this new string (a, e, i, o, u) and finally return
+     * (i.e. c becomes d, z becomes a). Then capitalize every vowel in this new string (a, e, i, o, u) and finally return
      * this modified string.
      */
     public static String shiftCharactersAndCapitalizeVowels(String str) {

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

@@ -7,17 +7,60 @@
 
 public class FactorialTest {
 
+    @Test
+    public void loop() {
+        assertThat("0!=1", Factorial.loop(0), is(1));
+        assertThat("1!=1", Factorial.loop(1), is(1));
+        assertThat("2!=2", Factorial.loop(2), is(2));
+        assertThat("3!=6", Factorial.loop(3), is(6));
+        assertThat("8!=40320", Factorial.loop(8), is(40320));
+    }
+
+
+    @Test(expected = IllegalArgumentException.class)
+    public void loopForNegativeParam() {
+        Factorial.loop(-1);
+    }
+
+    @Test
+    public void recursion() {
+        assertThat("0!=1", Factorial.recursion(0), is(1));
+        assertThat("1!=1", Factorial.recursion(1), is(1));
+        assertThat("2!=2", Factorial.recursion(2), is(2));
+        assertThat("3!=6", Factorial.recursion(3), is(6));
+        assertThat("8!=40320", Factorial.recursion(8), is(40320));
+    }
+
     @Test(expected = IllegalArgumentException.class)
-    public void calculateForNegativeParam() {
-        Factorial.calculate(-1);
+    public void recursionForNegativeParam() {
+        Factorial.recursion(-1);
     }
 
     @Test
-    public void calculate() {
-        assertThat("0!=1", Factorial.calculate(0), is(1));
-        assertThat("1!=1", Factorial.calculate(1), is(1));
-        assertThat("2!=2", Factorial.calculate(2), is(2));
-        assertThat("3!=6", Factorial.calculate(3), is(6));
-        assertThat("8!=40320", Factorial.calculate(8), is(40320));
+    public void recursionWithCache() {
+        assertThat("0!=1", Factorial.recursionWithCache(0), is(1));
+        assertThat("1!=1", Factorial.recursionWithCache(1), is(1));
+        assertThat("2!=2", Factorial.recursionWithCache(2), is(2));
+        assertThat("3!=6", Factorial.recursionWithCache(3), is(6));
+        assertThat("8!=40320", Factorial.recursionWithCache(8), is(40320));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void recursionWithCacheForNegativeParam() {
+        Factorial.recursionWithCache(-1);
+    }
+
+    @Test
+    public void loopWithCache() {
+        assertThat("0!=1", Factorial.loopWithCache(0), is(1));
+        assertThat("1!=1", Factorial.loopWithCache(1), is(1));
+        assertThat("2!=2", Factorial.loopWithCache(2), is(2));
+        assertThat("3!=6", Factorial.loopWithCache(3), is(6));
+        assertThat("8!=40320", Factorial.loopWithCache(8), is(40320));
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void loopWithCacheForNegativeParam() {
+        Factorial.loopWithCache(-1);
     }
 }