Memoize - Practice Coding Problems

Memoize - Problem

JavaScript Medium

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 from previous computations, dramatically improving performance for expensive recursive operations.

You can assume there are 3 possible input functions:

sum accepts two integers a and b and returns a + b. Note that arguments (3, 2) and (2, 3) are considered different and require separate cache entries.
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.

Goal: Transform any function into an optimized version that caches results to avoid redundant calculations.

Input & Output

example_1.js — Sum Function Memoization

$ Input: fn = sum, calls = [[2,2], [2,2], [1,2]]

› Output: calls count: 2 (cache hit on second [2,2])

💡 Note: The sum function is called with [2,2] twice, but the second call returns the cached result. [1,2] requires a new computation since it's different from [2,2].

example_2.js — Fibonacci Memoization

$ Input: fn = fib, calls = [5, 5, 6, 5]

› Output: calls count: 6 (fib(5) computed once, fib(6) needs fib(5) from cache)

💡 Note: fib(5) is computed once and cached. When fib(6) is called, it reuses the cached fib(5) result. The final fib(5) call is a direct cache hit.

example_3.js — Factorial Edge Case

$ Input: fn = factorial, calls = [1, 1, 2, 1]

› Output: calls count: 2 (factorial(1) cached, factorial(2) calls factorial(1))

💡 Note: factorial(1) is cached on first call. factorial(2) computes 2 * factorial(1), using the cached value. The final factorial(1) is a cache hit.

Constraints

The function will always be one of: sum, fib, or factorial
For sum: arguments are integers where -100 ≤ a, b ≤ 100
For fib and factorial: 0 ≤ n ≤ 50
Arguments order matters: sum(2,3) ≠ sum(3,2) in cache
Cache should persist across multiple function calls

Visualization

Tap to expand

Understanding the Visualization

Function Call

A function is called with specific arguments

Cache Check

Check if this exact computation has been done before

Cache Hit/Miss

If found, return cached result. If not, compute and cache the result

Performance Gain

Future calls with same arguments return instantly

Key Takeaway

🎯 Key Insight: Memoization trades memory space for computational time, transforming exponential algorithms into linear ones by caching results.

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses a hash map cache to store previously computed results. Before calling the original function, check if the result exists in cache - if so, return it instantly. Otherwise, compute the result, store it in cache, and return it. This transforms exponential time complexity O(2^n) into linear O(n) for recursive functions like Fibonacci.

Common Approaches

Approach	Time	Space	Notes
✓ No Memoization (Original Function)	O(2^n)	O(n)	Call the original function every time without any caching
Hash Map Memoization (Optimal)	O(n)	O(n)	Cache function results in a hash map for instant lookup of previously computed values

No Memoization (Original Function) — Algorithm Steps

Return the original function as-is
Every call triggers full computation
No memory of previous results
Redundant calculations for same inputs

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Call

fib(5) starts the recursive tree

Branching

Each call branches into two recursive calls

Redundancy

Same values like fib(2) are calculated multiple times

Code -

solution.c — C

#include <stdio.h>

typedef int (*IntFunc)(int);

int fib_impl(int n) {
    if (n <= 1) return 1;
    return fib_impl(n - 1) + fib_impl(n - 2);
}

IntFunc memoize(IntFunc fn) {
    // No memoization - just return original function
    return fn;
}

int main() {
    IntFunc memoizedFib = memoize(fib_impl);
    printf("%d\n", memoizedFib(10));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

For Fibonacci, each call branches into two recursive calls, creating exponential growth

⚠ Quadratic Growth

Space Complexity

O(n)

Call stack depth for recursive functions

⚡ Linearithmic Space

24.7K Views

High Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

No Memoization (Original Function) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler