ES6 implementation of Factorial and Fibonacci added

Author: me-shaon

Number Theory/Factorial/es6/factorial.js

@@ -0,0 +1,53 @@
+/*
+    Factorial Calculation in JavaScript(ES6)
+    -----------------------------------
+
+    As Factorial numbers can be calculated using the formula:
+        Factorial[n] = 1 * 2 * 3 * ...... * n
+    We can easily calculate n-th factorial number multiplying
+    all the previous numbers.
+
+    NOTE: remember that, the Factorial[N] can be very large
+        for a very small value of N. So always be careful about
+        the result being overflowed of Number limit.
+        Calculating large values of Factorial needs some extra
+        optimization and tricks based on the task to be solved.
+*/
+
+const factorial = (n) => {
+    let fact = 1;
+
+  	while(n) {
+        fact *= n;
+        n--;
+    }
+
+    return fact;
+}
+
+
+/*
+  Solving Factorial using recursion.
+  Recursive formula for Factorial is: F[n] = n * F[n-1]
+*/
+const recursiveFactorial = (n) => (n === 0) ? 1 : (n * recursiveFactorial(n-1));
+
+/* Following is an optimized version of calculating Factorial using 'Memoization' or
+  'Dynamic Programming'.
+  To understand how this is actually working you need to read the following article first:
+  https://medium.freecodecamp.org/understanding-memoize-in-javascript-51d07d19430e
+*/
+
+const memoizedFunction = (fn) => {
+  var cache = {};
+
+  return (n) => (n in cache) ? cache[n] : (cache[n] = fn(n));
+}
+
+const memoizedFactorial = memoizedFunction((x) => (x === 0) ? 1 : (x * memoizedFactorial(x-1)));
+
+module.exports = {
+  factorial,
+  recursiveFactorial,
+  memoizedFactorial
+}

Number Theory/Factorial/es6/test.js

@@ -0,0 +1,20 @@
+const { factorial, recursiveFactorial, memoizedFactorial } = require('./factorial')
+
+console.log('====== Simple Factorial ==========');
+console.log(factorial(1));
+console.log(factorial(2));
+console.log(factorial(3));
+console.log(factorial(4));
+console.log(factorial(5));
+console.log(factorial(10));
+console.log(factorial(20));
+
+console.log('====== Recursive Factorial ==========');
+console.log(recursiveFactorial(10));
+console.log(recursiveFactorial(20));
+
+console.log('====== Memoized Factorial ==========');
+console.log(memoizedFactorial(5));
+console.log(memoizedFactorial(6));
+console.log(memoizedFactorial(5));
+console.log(memoizedFactorial(10));

Number Theory/Fibonacci/es6/fibonacci.js

@@ -0,0 +1,56 @@
+/*
+    Fibonacci Calculation in JavaScript(ES6)
+    -----------------------------------
+
+    As fibonacci numbers follow the pattern of:
+        Fib[n] = Fib[n-1] + Fib[n-2]
+    (having the base case of starting values-> Fib[0] = 0 and Fib[1] = 1)
+    We can easily calculate n-th fibonacci number calculating
+    all the previous values by this formula.
+
+    NOTE: remember that, the Fibonacci[N] can be very large
+        for a very small value of N (You can safely calculate almost upto N=97).
+        So always be careful about the result being overflowed of Number limit.
+        Calculating large values of Fibonacci needs some extra
+        optimization and tricks based on the task to be solved.
+*/
+
+const fibonacci = (n) => {
+    let fib, a = 0, b = 1;
+
+    if(n === 0 || n === 1) return n;
+
+    while(--n) {
+        fib = a + b;
+        a = b;
+        b = fib;
+    }
+
+    return fib;
+}
+
+/*
+  Solving Fibonacci using recursion.
+  Recursive formula for Fibonacci is: F[n] = F[n-1] + F[n-2]
+*/
+const recursiveFibonacci = (n) => (n === 0 || n === 1) ? n : (recursiveFibonacci(n-1) + recursiveFibonacci(n-2));
+
+/* Following is an optimized version of calculating Fibonacci using 'Memoization' or
+  'Dynamic Programming'.
+  To understand how this is actually working you need to read the following article first:
+  https://medium.freecodecamp.org/understanding-memoize-in-javascript-51d07d19430e
+*/
+
+const memoizedFunction = (fn) => {
+  var cache = {};
+
+  return (n) => (n in cache) ? cache[n] : (cache[n] = fn(n));
+}
+
+const memoizedFibonacci = memoizedFunction((x) => (x === 0 || x === 1) ? x : (memoizedFibonacci(x - 1) + memoizedFibonacci(x - 2)));
+
+module.exports = {
+  fibonacci,
+  recursiveFibonacci,
+  memoizedFibonacci
+}

Number Theory/Fibonacci/es6/test.js

@@ -0,0 +1,18 @@
+const { fibonacci, recursiveFibonacci, memoizedFibonacci } = require('./fibonacci')
+
+console.log('====== Simple Fibonacci ==========');
+console.log(fibonacci(1));
+console.log(fibonacci(2));
+console.log(fibonacci(3));
+console.log(fibonacci(4));
+console.log(fibonacci(5));
+console.log(fibonacci(10));
+
+console.log('====== Recursive Fibonacci ==========');
+console.log(recursiveFibonacci(5));
+console.log(recursiveFibonacci(10));
+
+console.log('====== Memoized Fibonacci ==========');
+console.log(memoizedFibonacci(5));
+console.log(memoizedFibonacci(6));
+console.log(memoizedFibonacci(10));