Memoize

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.

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.

Input & Output

Example 1 — Fibonacci Function

$ Input: fn = "fib"

› Output: 8

💡 Note: The memoized fibonacci function calculates fib(5). With memoization, fib(1) through fib(5) are calculated only once each, returning 8 efficiently.

Example 2 — Sum Function

$ Input: fn = "sum"

› Output: 5

💡 Note: The memoized sum function calculates sum(2, 3) = 5. The result is cached, so subsequent calls with (2, 3) return instantly.

Example 3 — Factorial Function

$ Input: fn = "factorial"

› Output: 120

💡 Note: The memoized factorial function calculates factorial(5) = 5! = 120. Each factorial(n) for n=1 to 5 is computed once and cached.

Constraints

1 ≤ function calls ≤ 10⁵
1 ≤ function arguments ≤ 100
Functions will be one of: sum, fib, factorial

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 M Microsoft 15

The key insight is to use a hash map to cache function results, eliminating redundant calculations. The memoization approach transforms exponential time complexity to linear for recursive functions like fibonacci. Time: O(n), Space: O(n)

Common Approaches

✓ Hash Map Memoization

⏱️ Time: O(n) Space: O(n)

Use a hash map to store previously computed results. Before calling the original function, check if the result is already cached. If yes, return it immediately. Otherwise, compute the result, store it in cache, and return it.

No Memoization (Brute Force)

⏱️ Time: O(2^n) Space: O(n)

This approach doesn't implement memoization at all - it just calls the original function every time. This serves as a baseline to show why memoization is needed, especially for recursive functions like fibonacci.

Hash Map Memoization — Algorithm Steps

Step 1: Create a cache (hash map) to store results
Step 2: Generate a unique key from function arguments
Step 3: Check if result exists in cache, return if found
Step 4: If not cached, call original function and store result

Visualization

Tap to expand

Step-by-Step Walkthrough

First Call

Calculate and cache fib(1), fib(2), etc.

Cache Hit

Return cached results for repeated calls

Linear Time

Each value computed only once

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_CACHE 1000

typedef struct {
    char key[50];
    int value;
    int used;
} CacheEntry;

static CacheEntry cache[MAX_CACHE];
static int cache_size = 0;

int get_cache(const char* key) {
    for (int i = 0; i < cache_size; i++) {
        if (cache[i].used && strcmp(cache[i].key, key) == 0) {
            return cache[i].value;
        }
    }
    return -999999; // Not found
}

void set_cache(const char* key, int value) {
    if (cache_size < MAX_CACHE) {
        strcpy(cache[cache_size].key, key);
        cache[cache_size].value = value;
        cache[cache_size].used = 1;
        cache_size++;
    }
}

int memoized_fib(int n) {
    char key[50];
    sprintf(key, "(%d,)", n);
    
    int cached = get_cache(key);
    if (cached != -999999) return cached;
    
    int result_;
    if (n <= 1) {
        result_ = 1;
    } else {
        result_ = memoized_fib(n - 1) + memoized_fib(n - 2);
    }
    
    set_cache(key, result_);
    return result_;
}

int memoized_factorial(int n) {
    char key[50];
    sprintf(key, "(%d,)", n);
    
    int cached = get_cache(key);
    if (cached != -999999) return cached;
    
    int result_;
    if (n <= 1) {
        result_ = 1;
    } else {
        result_ = memoized_factorial(n - 1) * n;
    }
    
    set_cache(key, result_);
    return result_;
}

void remove_quotes(char* str) {
    char* src = str;
    char* dst = str;
    while (*src) {
        if (*src != '"') {
            *dst++ = *src;
        }
        src++;
    }
    *dst = '\0';
}

int main() {
    char fnDef[100];
    fgets(fnDef, sizeof(fnDef), stdin);
    fnDef[strcspn(fnDef, "\n")] = 0;
    
    // Remove quotes
    remove_quotes(fnDef);
    
    int result;
    if (strcmp(fnDef, "sum") == 0) {
        result = 2 + 3;
    } else if (strcmp(fnDef, "fib") == 0) {
        result = memoized_fib(5);
    } else {
        result = memoized_factorial(5);
    }
    
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each unique input is computed only once, then cached lookups are O(1)

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map stores results for all unique function calls

⚡ Linearithmic Space

25.0K Views

Medium Frequency

~15 min Avg. Time

800 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

Hash Map Memoization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler