Memoize II - Practice Coding Problems

Memoize II - Problem

JavaScript Hard

You're tasked with creating an advanced memoization function that can optimize any given function by caching its results. Unlike basic memoization, this version must handle complex input types including objects, arrays, and nested structures.

Given a function fn, return a memoized version that:

Never calls the original function twice with identical inputs
Returns cached results for previously seen argument combinations
Handles any data types as function parameters
Uses === strict equality for input comparison

The challenge lies in creating an efficient caching mechanism that works with any combination of argument types while maintaining optimal performance.

Input & Output

example_1.js — Basic Number Function

$ Input: let callCount = 0; const memoizedFn = memoize(function (a, b) { callCount += 1; return a + b; }); memoizedFn(2, 3); // 5 memoizedFn(2, 3); // 5 console.log(callCount); // 1

› Output: 1

💡 Note: The function is only called once. The second call with identical arguments (2, 3) returns the cached result without executing the original function.

example_2.js — Object Arguments

$ Input: let callCount = 0; const memoizedFn = memoize(function (a) { callCount += 1; return a.value * 2; }); const obj = {value: 5}; memoizedFn(obj); // 10 memoizedFn(obj); // 10 console.log(callCount); // 1

› Output: 1

💡 Note: Even with object arguments, the memoization works correctly using reference equality. The same object reference triggers cache hit.

example_3.js — Different Arguments

$ Input: let callCount = 0; const memoizedFn = memoize(function (a, b) { callCount += 1; return a * b; }); memoizedFn(2, 3); // 6 memoizedFn(3, 2); // 6 console.log(callCount); // 2

› Output: 2

💡 Note: Different argument combinations (2,3) vs (3,2) are treated as separate cache entries, so the function is called twice.

Constraints

The function can accept 0 to 10 arguments
Arguments can be of any type: primitives, objects, arrays, functions
The function can return any type of value
Inputs are considered identical only if they are === equal
Cache size is unlimited - no automatic cleanup

Visualization

Tap to expand

Understanding the Visualization

First Call

Function executes normally, result stored in cache

Cache Storage

Arguments become cache key, result becomes cached value

Subsequent Calls

Same arguments trigger cache hit, return instant result

Performance Boost

Expensive computations avoided, dramatic speed improvement

Key Takeaway

🎯 Key Insight: Memoization trades memory for speed, converting expensive repeated computations into instant cache lookups using hash map optimization.

Asked in

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

The optimal solution uses a hash map (Map object) to cache function results with O(1) lookup time. Create a cache key from the arguments and store results in a Map. This approach handles any argument types efficiently while providing excellent performance for repeated calls with identical inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map Cache (Optimal)	O(1)	O(n)	Use Map with serialized argument keys for O(1) lookup
Simple Array-Based Cache	O(n*m)	O(k)	Use array to store argument combinations and results
No Caching (Brute Force)	O(f(n))	O(1)	Always call the original function without any memoization

Hash Map Cache (Optimal) — Algorithm Steps

Initialize a Map to store cached results
Create a cache key by serializing the arguments
Check if the key exists in the Map
If key exists, return the cached result
If key doesn't exist, compute result and store in Map

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Key

Serialize arguments into cache key

Hash Lookup

Check if key exists in Map (O(1) operation)

Return Result

Either return cached value or compute and cache new result

Code -

solution.c — C

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

#define HASH_SIZE 1009
#define MAX_KEY_LEN 256

typedef struct CacheNode {
    char key[MAX_KEY_LEN];
    int result;
    struct CacheNode* next;
} CacheNode;

static CacheNode* hash_table[HASH_SIZE];

unsigned int hash_function(const char* key) {
    unsigned int hash = 5381;
    int c;
    while ((c = *key++)) {
        hash = ((hash << 5) + hash) + c;
    }
    return hash % HASH_SIZE;
}

int get_cached_result(const char* key) {
    unsigned int index = hash_function(key);
    CacheNode* node = hash_table[index];
    
    while (node != NULL) {
        if (strcmp(node->key, key) == 0) {
            return node->result;
        }
        node = node->next;
    }
    return -1; // Not found
}

void cache_result(const char* key, int result) {
    unsigned int index = hash_function(key);
    CacheNode* new_node = malloc(sizeof(CacheNode));
    
    strcpy(new_node->key, key);
    new_node->result = result;
    new_node->next = hash_table[index];
    hash_table[index] = new_node;
}

int memoized_function(int (*fn)(int, int), int a, int b) {
    char key[MAX_KEY_LEN];
    snprintf(key, sizeof(key), "%d,%d", a, b);
    
    int cached = get_cached_result(key);
    if (cached != -1) {
        return cached;
    }
    
    int result = fn(a, b);
    cache_result(key, result);
    return result;
}

int expensive_multiply(int a, int b) {
    int result = 0;
    for (int i = 0; i < 1000000; i++) {
        result = a * b;
    }
    return result;
}

int main() {
    printf("First call: %d\n", memoized_function(expensive_multiply, 42, 7));
    printf("Second call: %d\n", memoized_function(expensive_multiply, 42, 7));
    
    // Clean up memory
    for (int i = 0; i < HASH_SIZE; i++) {
        CacheNode* node = hash_table[i];
        while (node != NULL) {
            CacheNode* temp = node;
            node = node->next;
            free(temp);
        }
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Average O(1) hash map lookup after O(k) serialization where k is argument size

✓ Linear Growth

Space Complexity

O(n)

n is the number of unique function calls cached in the Map

⚡ Linearithmic Space

58.9K Views

High Frequency

~15 min Avg. Time

2.8K 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 Cache (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler