added Memoization-in-JS

Author: Varunyadavgithub

Hard/Memoization-in-JS.md

@@ -0,0 +1,177 @@
+### **What is Memoization in JavaScript ?**
+
+Memoization is an optimization technique used in programming to improve the performance of functions by storing the results of expensive function calls and returning the cached result when the same inputs occur again. In JavaScript, memoization is particularly useful when dealing with recursive functions, computationally intensive operations, or functions that are called multiple times with the same arguments.
+
+---
+
+### **How Memoization Works**
+
+Memoization works by maintaining a cache (a data structure like an object or a Map) where results of function calls are stored. The function checks this cache before performing any computation:
+
+- **If a result exists for the given input(s):** The cached result is returned, saving time and resources.
+- **If a result does not exist:** The function computes the result, stores it in the cache, and then returns it.
+
+---
+
+### **Key Benefits of Memoization**
+
+1. **Performance Improvement:** Reduces redundant calculations by reusing previously computed results.
+2. **Efficiency in Recursion:** Particularly useful for recursive algorithms like Fibonacci sequence or factorial computations.
+3. **Reduced Resource Usage:** Avoids repeated execution of heavy computations, saving CPU cycles.
+
+---
+
+### **Memoization in Practice**
+
+#### **Basic Example of Memoization**
+
+Here’s a simple implementation of memoization in JavaScript:
+
+```javascript
+function memoize(fn) {
+  const cache = new Map(); // Using a Map to store results for better performance
+  return function (...args) {
+    const key = JSON.stringify(args); // Serialize arguments as the cache key
+    if (cache.has(key)) {
+      console.log("Fetching from cache:", key);
+      return cache.get(key); // Return cached result if available
+    }
+    console.log("Computing result for:", key);
+    const result = fn(...args); // Compute the result
+    cache.set(key, result); // Store the result in the cache
+    return result;
+  };
+}
+
+// Example function to memoize
+function add(a, b) {
+  return a + b;
+}
+
+// Memoized version of the function
+const memoizedAdd = memoize(add);
+
+console.log(memoizedAdd(1, 2)); // Computing result for: [1,2]
+console.log(memoizedAdd(1, 2)); // Fetching from cache: [1,2]
+console.log(memoizedAdd(2, 3)); // Computing result for: [2,3]
+```
+
+#### **Explanation of the Example:**
+
+1. The `memoize` function creates a wrapper around the provided function (`add` in this case).
+2. A `Map` is used to store the cached results.
+3. Each function call is checked against the cache. If the result exists, it is fetched directly; otherwise, it is computed and stored.
+
+---
+
+### **Use Case: Recursive Functions (Fibonacci)**
+
+Recursive functions often involve repeated computations for the same inputs. Memoization can drastically improve their efficiency.
+
+#### **Naive Fibonacci Function**
+
+```javascript
+function fibonacci(n) {
+  if (n <= 1) return n;
+  return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+console.log(fibonacci(10)); // Takes exponential time (O(2^n))
+```
+
+#### **Optimized Fibonacci with Memoization**
+
+```javascript
+function memoize(fn) {
+  const cache = new Map();
+  return function (...args) {
+    const key = args[0]; // Using the first argument as the key
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+}
+
+const fibonacci = memoize(function (n) {
+  if (n <= 1) return n;
+  return fibonacci(n - 1) + fibonacci(n - 2);
+});
+
+console.log(fibonacci(10)); // Much faster with O(n) complexity
+```
+
+#### **Explanation:**
+
+- Without memoization, the Fibonacci function repeatedly computes the same values.
+- With memoization, results for each `n` are stored and reused, reducing the time complexity from \(O(2^n)\) to \(O(n)\).
+
+---
+
+### **Memoization in Modern JavaScript**
+
+#### **Using Closures**
+
+Memoization can leverage closures to encapsulate the cache and function logic.
+
+```javascript
+function memoizedFactorial() {
+  const cache = {};
+  return function factorial(n) {
+    if (n in cache) {
+      return cache[n];
+    }
+    if (n === 0 || n === 1) {
+      return 1;
+    }
+    const result = n * factorial(n - 1);
+    cache[n] = result;
+    return result;
+  };
+}
+
+const factorial = memoizedFactorial();
+console.log(factorial(5)); // Computes and caches results
+console.log(factorial(5)); // Fetches from cache
+```
+
+---
+
+### **Advantages of Memoization**
+
+- **Efficiency:** Saves computational resources by avoiding redundant calculations.
+- **Speed:** Accelerates execution for functions with repeated calls and identical inputs.
+- **Improved Recursive Functions:** Particularly valuable in recursive algorithms like Fibonacci, factorial, and dynamic programming problems.
+
+---
+
+### **Challenges and Best Practices**
+
+1. **Cache Size Management:** Large caches may consume significant memory. Consider setting a limit.
+   - Use strategies like Least Recently Used (LRU) caching.
+   - Libraries like `lru-cache` implement such mechanisms efficiently.
+2. **Cache Keys:** Ensure the uniqueness of cache keys.
+
+   - Use robust serialization methods for complex arguments (e.g., `JSON.stringify`).
+
+3. **Suitability:** Memoization is not always suitable for functions with side effects or unpredictable outputs (e.g., random numbers, API calls).
+
+4. **Testing and Debugging:** Caching introduces complexity. Test thoroughly to avoid unexpected results.
+
+---
+
+### **When to Use Memoization**
+
+- **Recursive Functions:** E.g., Fibonacci, factorial, dynamic programming.
+- **Expensive Computations:** Calculations that consume significant time and resources.
+- **Repeated Calls with Same Inputs:** Situations where functions are invoked with identical arguments multiple times.
+
+---
+
+### **Conclusion**
+
+Memoization is a powerful technique in JavaScript to enhance the performance of functions by caching results for repeated inputs. While it is highly effective in specific scenarios like recursion and expensive computations, it should be used judiciously to avoid unnecessary complexity or memory overhead. With the right implementation, memoization can significantly improve the efficiency of your JavaScript code.
+
+---

Hard/README.md

@@ -6,7 +6,7 @@ This section contains advanced JavaScript interview questions. Click on each que
 2.  [What is the purpose of the async and await keywords?](Purpose-of-async-and-await.md) ✅
 3.  [Explain the working of the Event Loop.](Working-of-event-loop.md) ✅
 4.  [How can you remove duplicates from an array in JavaScript?](Remove-duplicates-from-array.md)
-5.  [What is memoization in JavaScript?](Memoization-in-JS.md)
+5.  [What is memoization in JavaScript?](Memoization-in-JS.md) ✅
 6.  [What is the difference between innerHTML and innerText?](Difference-between-innerHTML-and-innerText.md) ✅
 7.  [Explain how localStorage, sessionStorage, and cookies differ.](Difference-between-localStorage-sessionStorage-cookies.md)
 8.  [What is destructuring in JavaScript, and how does it work?](Destructuring-in-JS.md) ✅