Immutability Helper

Immutability Helper - Problem

JavaScript Hard

Creating clones of immutable objects with minor alterations can be a tedious process. Write a class ImmutableHelper that serves as a tool to help with this requirement.

The constructor accepts an immutable object obj which will be a JSON object or array. The class has a single method produce which accepts a function mutator. The function returns a new object which is similar to the original except it has those mutations applied.

mutator accepts a proxied version of obj. A user of this function can (appear to) mutate this object, but the original object obj should not actually be affected.

Example usage:

const originalObj = {"x": 5};
const helper = new ImmutableHelper(originalObj);
const newObj = helper.produce((proxy) => {
  proxy.x = proxy.x + 1;
});
console.log(originalObj); // {"x": 5}
console.log(newObj); // {"x": 6}

Properties of the mutator function:

It will always return undefined
It will never access keys that don't exist
It will never delete keys (delete obj.key)
It will never call methods on a proxied object (push, shift, etc)
It will never set keys to objects (proxy.x = {})

Input & Output

Example 1 — Basic Property Modification

$ Input: obj = {"x": 5}, mutator = "proxy.x = proxy.x + 1"

› Output: {"x": 6}

💡 Note: The mutator increments the x property from 5 to 6. Original object remains {"x": 5}, new object becomes {"x": 6}

Example 2 — Multiple Properties

$ Input: obj = {"a": 1, "b": 2}, mutator = "proxy.a = 10; proxy.b = 20"

› Output: {"a": 10, "b": 20}

💡 Note: Both properties are modified: a changes from 1 to 10, b changes from 2 to 20

Example 3 — Array Modification

$ Input: obj = [1, 2, 3], mutator = "proxy[0] = 99"

› Output: [99, 2, 3]

💡 Note: First element of array changes from 1 to 99, other elements remain unchanged

Constraints

obj will be a valid JSON object or array
mutator will only perform allowed operations
mutator will not access non-existent keys
mutator will not delete properties
mutator will not assign objects as values

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 M Microsoft 22

The key insight is to use JavaScript's Proxy feature to intercept property mutations and apply them to a copy without affecting the original. The optimal approach uses copy-on-write with proxy interception for efficient immutable updates. Time: O(m + d), Space: O(m + d) where m is mutations and d is depth.

Common Approaches

✓ Deep Clone + Direct Mutation

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

The simplest approach is to create a complete deep copy of the original object, then let the mutator function modify this copy directly. This ensures the original remains unchanged.

Proxy-Based Copy-on-Write

⏱️ Time: O(m + d) Space: O(m + d)

This approach uses JavaScript's Proxy feature to intercept property access and mutations. When a property is read, it returns the original value. When a property is written, it triggers a copy-on-write mechanism that only copies the necessary parts of the object tree.

Deep Clone + Direct Mutation — Algorithm Steps

Step 1: Create a deep clone of the original object
Step 2: Apply the mutator function to the clone
Step 3: Return the modified clone

Visualization

Tap to expand

Step-by-Step Walkthrough

Original Object

Start with original {x: 5}

Deep Clone

Create complete copy of entire structure

Apply Mutations

Modify the clone directly to get {x: 6}

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

cJSON* solution(cJSON* obj, char* mutatorCode) {
    // Create deep copy
    char* jsonString = cJSON_Print(obj);
    cJSON* clone = cJSON_Parse(jsonString);
    free(jsonString);
    return clone;
}

int main() {
    char objLine[1000], mutatorCode[1000];
    fgets(objLine, sizeof(objLine), stdin);
    fgets(mutatorCode, sizeof(mutatorCode), stdin);
    
    objLine[strcspn(objLine, "\n")] = 0;
    mutatorCode[strcspn(mutatorCode, "\n")] = 0;
    
    cJSON* obj = cJSON_Parse(objLine);
    cJSON* result = solution(obj, mutatorCode);
    
    char* output = cJSON_Print(result);
    printf("%s\n", output);
    
    free(output);
    cJSON_Delete(obj);
    cJSON_Delete(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Deep cloning requires visiting every property in the object

✓ Linear Growth

Space Complexity

O(n)

Creates a complete copy of the original object structure

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~35 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

Deep Clone + Direct Mutation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler