Memoize II

Memoize II - Problem

JavaScript Hard

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.

The function fn can be any function and there are no constraints on what type of values it accepts. Inputs are considered identical if they are === to each other.

Input & Output

Example 1 — Basic Function Memoization

$ Input: fn = (a, b) => a + b

› Output: memoized function that caches results

💡 Note: First call fn(2,3) computes 5 and caches it. Second call fn(2,3) returns cached 5 without computation.

Example 2 — Factorial Memoization

$ Input: fn = (n) => n <= 1 ? 1 : n * fn(n-1)

› Output: memoized factorial function

💡 Note: Recursive calls get memoized. factorial(5) caches results for 1,2,3,4,5. Later calls reuse cached values.

Example 3 — Object Arguments

$ Input: fn = (obj) => obj.x + obj.y

› Output: memoized function handling objects

💡 Note: Same object reference returns cached result. Different objects with same values are treated as different inputs.

Constraints

1 ≤ inputs.length ≤ 10⁵
0 ≤ inputs.flat().length ≤ 10⁵
inputs[i][j] != NaN

Visualization

Tap to expand

Asked in

G Google 45 f Facebook 38 a Amazon 32 M Microsoft 28

The key insight is to cache function results using arguments as keys. Best approach uses Map/WeakMap for efficient caching with proper memory management. Time: O(1), Space: O(n)

Common Approaches

✓ Basic Cache with JSON Stringify

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

Convert function arguments to a JSON string to use as cache key. This works for most cases but may fail with functions, undefined values, or objects with different property orders.

Map with Argument-based Keys

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

Create a custom key from arguments using a more robust method than JSON.stringify. This approach handles edge cases better and provides more control over the caching mechanism.

WeakMap with Object Reference Caching

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

Implement a sophisticated caching system using WeakMap for object arguments and regular Map for primitives. This handles complex data structures while preventing memory leaks through weak references.

Basic Cache with JSON Stringify — Algorithm Steps

Create a cache object
Convert arguments to JSON string key
Check cache, return if exists
Otherwise call function and cache result

Visualization

Tap to expand

Step-by-Step Walkthrough

Convert Args

JSON.stringify([a, b]) creates cache key

Check Cache

Look up key in cache object

Store Result

Cache result if not found

Code -

solution.c — C

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

typedef struct CacheEntry {
    char* key;
    int value;
    struct CacheEntry* next;
} CacheEntry;

typedef struct {
    CacheEntry* head;
    int (*original_fn)(int, int);
} MemoizedFunction;

int memoized_call(MemoizedFunction* memo, int a, int b) {
    char key[50];
    sprintf(key, "%d,%d", a, b);
    
    CacheEntry* current = memo->head;
    while (current) {
        if (strcmp(current->key, key) == 0) {
            return current->value;
        }
        current = current->next;
    }
    
    int result = memo->original_fn(a, b);
    
    CacheEntry* new_entry = malloc(sizeof(CacheEntry));
    new_entry->key = malloc(strlen(key) + 1);
    strcpy(new_entry->key, key);
    new_entry->value = result;
    new_entry->next = memo->head;
    memo->head = new_entry;
    
    return result;
}

MemoizedFunction* solution(int (*fn)(int, int)) {
    MemoizedFunction* memo = malloc(sizeof(MemoizedFunction));
    memo->head = NULL;
    memo->original_fn = fn;
    return memo;
}

int test_sum(int a, int b) {
    return a + b;
}

int main() {
    char fnType[20];
    fgets(fnType, sizeof(fnType), stdin);
    fnType[strcspn(fnType, "\n")] = 0;
    
    MemoizedFunction* memoized = solution(test_sum);
    printf("memoized_function\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Cache lookup and storage are constant time operations

✓ Linear Growth

Space Complexity

O(n)

Cache stores results for n unique function calls

⚡ Linearithmic Space

24.5K Views

Medium Frequency

~25 min Avg. Time

856 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

Basic Cache with JSON Stringify — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler