**Memoization** is a specific form of caching used in dynamic programming. **Caching** is a way to speed our programs and hold some data in an accessible box for later use. It stores the previous result and returns the others instantaneously when we call without delay. 

In addition, memoization is an optimization technique in caching that results when the same set of arguments result in the same output and performant web applications.

#   
## Fibonacci sequence

Let's write a function to compute the Fibonacci sequence without memorization.

> The **Fibonacci sequence** represents a list of numbers where each value is the sum of the two previous values.


// fibonacci without memoization
const fib = (num) => {
    if (num < 2) {
        return 1
    } else if (!num || typeof num !== 'number') {
        return 'value must be a number!'
    }
    return fib(num - 1) + fib(num - 2)
}

console.log(fib(10))

codemirror

console

From the code above, we didn't cache the execution of our function. The process will be a lot quicker in less time with caching.

// fibonacci sequence with memoization to run the function fib()
const fib = (num) => {
    let cache = {}; // set cache
    // if exists in cache return from cache
    if (cache[num] !== undefined) {
        console.log(`${num} is cached!`);
        return cache[num];
    }
    // if not in cache perform operation
    cache[num] = num < 2 ? 1 : fib(num - 1) + fib(num - 2);
    return cache[num];
}
const result = fib(5)
console.log(result) // 8

From the code snippet above, we created a cache object that the `fib()` uses to store its output value. Each time the function is called, it first checks whether the input `num` has been stored previously in the cache object. If it has, it immediately returns the cached value as the program    

#   
## Exercise
Let's find the factorial of a given number using the cache execution of a `factorial()` function.

// factorial of a number with memoization (cache execution)
const factorial = (num) => {
  let cache = {}; // set cache
  // if cache already exists, return cache
  if (cache[num] !== undefined) {
    console.log(`${num} is cached!`);
    return cache[num];
    // edge case validation for not a number
  } else if(!num || typeof num != 'number') {
      return `value must be a number`
    }
  cache[num] = 
    num === 0 
    ? 1 : num === 2 ? 2 
    : num * factorial(num - 1); // condition ternary operator, same with if/else statement
  return cache[num];
};

console.log(factorial(5)); // 120

What is memoization?

Memoization is a specific form of caching used in dynamic programming. Caching is a way to speed our programs and hold some data in an accessible box for later use. It stores the previous result and returns the others instantaneously when we call without delay. In addition, memoization is an optimization technique in caching that results when the same set of arguments result in the same output and performant web applications.  Fibonacci sequence Let s write a function to compute the Fibonacci sequence without memorization.  The Fibonacci sequence represents a list of numbers where each value is the sum of the two previous values.  