2623. Memoize LeetCode Solution

In this guide, you will get 2623. Memoize LeetCode Solution with the best time and space complexity. The solution to Memoize problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.

Table of Contents

  1. Problem Statement
  2. Complexity Analysis
  3. Memoize solution in C++
  4. Memoize solution in Java
  5. Memoize solution in Python
  6. Additional Resources
2623. Memoize LeetCode Solution image

Problem Statement of Memoize

Given a function fn, return a memoized version of that function.
A memoized function is a function that will never be called twice with the same inputs. Instead it will return a cached value.
You can assume there are 3 possible input functions: sum, fib, and factorial.

sum accepts two integers a and b and returns a + b. Assume that if a value has already been cached for the arguments (b, a) where a != b, it cannot be used for the arguments (a, b). For example, if the arguments are (3, 2) and (2, 3), two separate calls should be made.
fib accepts a single integer n and returns 1 if n <= 1 or fib(n – 1) + fib(n – 2) otherwise.
factorial accepts a single integer n and returns 1 if n <= 1 or factorial(n – 1) * n otherwise.

Example 1:

Input:
fnName = “sum”
actions = [“call”,”call”,”getCallCount”,”call”,”getCallCount”]
values = [[2,2],[2,2],[],[1,2],[]]
Output: [4,4,1,3,2]
Explanation:
const sum = (a, b) => a + b;
const memoizedSum = memoize(sum);
memoizedSum(2, 2); // “call” – returns 4. sum() was called as (2, 2) was not seen before.
memoizedSum(2, 2); // “call” – returns 4. However sum() was not called because the same inputs were seen before.
// “getCallCount” – total call count: 1
memoizedSum(1, 2); // “call” – returns 3. sum() was called as (1, 2) was not seen before.
// “getCallCount” – total call count: 2

See also  2813. Maximum Elegance of a K-Length Subsequence LeetCode Solution

Example 2:

Input:
fnName = “factorial”
actions = [“call”,”call”,”call”,”getCallCount”,”call”,”getCallCount”]
values = [[2],[3],[2],[],[3],[]]
Output: [2,6,2,2,6,2]
Explanation:
const factorial = (n) => (n <= 1) ? 1 : (n * factorial(n – 1));
const memoFactorial = memoize(factorial);
memoFactorial(2); // "call" – returns 2.
memoFactorial(3); // "call" – returns 6.
memoFactorial(2); // "call" – returns 2. However factorial was not called because 2 was seen before.
// "getCallCount" – total call count: 2
memoFactorial(3); // "call" – returns 6. However factorial was not called because 3 was seen before.
// "getCallCount" – total call count: 2

Example 3:

Input:
fnName = "fib"
actions = ["call","getCallCount"]
values = [[5],[]]
Output: [8,1]
Explanation:
fib(5) = 8 // "call"
// "getCallCount" – total call count: 1

Constraints:

0 <= a, b <= 105
1 <= n <= 10
1 <= actions.length <= 105
actions.length === values.length
actions[i] is one of "call" and "getCallCount"
fnName is one of "sum", "factorial" and "fib"

Complexity Analysis

  • Time Complexity: Google AdSense
  • Space Complexity: Google Analytics

2623. Memoize LeetCode Solution in C++

type Fn = (...params: number[]) => number;

function memoize(fn: Fn): Fn {
  const cache: Record<string, number> = {};
  return function (...args) {
    const key = args.join(' ');
    return cache[key] === undefined ? (cache[key] = fn(...args)) : cache[key];
  };
}
/* code provided by PROGIEZ */

2623. Memoize LeetCode Solution in Java

N/A
// code provided by PROGIEZ

2623. Memoize LeetCode Solution in Python

N/A
# code by PROGIEZ

Additional Resources

Happy Coding! Keep following PROGIEZ for more updates and solutions.