Immutability Helper - Practice Coding Problems

Immutability Helper - Problem

JavaScript Hard

The Immutability Challenge

In modern JavaScript development, immutability is a cornerstone principle that prevents unexpected side effects and makes code more predictable. However, creating modified copies of complex nested objects can be tedious and error-prone.

Your task is to implement an ImmutableHelper class that provides a clean, intuitive API for creating modified copies of immutable objects. The class should:

• Accept any JSON object or array in its constructor
• Provide a produce method that takes a mutator function
• Return a new object with changes applied, while keeping the original untouched
• Use JavaScript Proxy to create an illusion of direct mutation

Example:

const originalObj = {x: 5, nested: {y: 10}};
const helper = new ImmutableHelper(originalObj);
const newObj = helper.produce((proxy) => {
  proxy.x = proxy.x + 1;
  proxy.nested.y = 20;
});
console.log(originalObj); // {x: 5, nested: {y: 10}} - unchanged!
console.log(newObj);      // {x: 6, nested: {y: 20}} - modified copy

The mutator function receives a proxied version of the object that tracks all changes without affecting the original. Your implementation must handle nested objects and arrays while maintaining immutability.

Input & Output

basic_mutation.js — Basic Property Change

$ Input: const originalObj = {x: 5, y: 10}; const helper = new ImmutableHelper(originalObj); const newObj = helper.produce((proxy) => { proxy.x = proxy.x + 1; });

› Output: originalObj: {x: 5, y: 10} newObj: {x: 6, y: 10}

💡 Note: The proxy intercepts the assignment to `proxy.x` and creates a new object with the modified value while keeping the original unchanged.

nested_mutation.js — Nested Object Modification

$ Input: const originalObj = {user: {name: 'John', age: 30}, count: 5}; const helper = new ImmutableHelper(originalObj); const newObj = helper.produce((proxy) => { proxy.user.age = 31; proxy.count = 6; });

› Output: originalObj: {user: {name: 'John', age: 30}, count: 5} newObj: {user: {name: 'John', age: 31}, count: 6}

💡 Note: The proxy handles nested object access by creating proxies for nested objects, allowing deep mutations while preserving immutability of the original structure.

array_mutation.js — Array Modification

$ Input: const originalArr = [1, 2, {value: 3}]; const helper = new ImmutableHelper(originalArr); const newArr = helper.produce((proxy) => { proxy[0] = 10; proxy[2].value = 30; });

› Output: originalArr: [1, 2, {value: 3}] newArr: [10, 2, {value: 30}]

💡 Note: Arrays are handled just like objects, with array indices treated as properties. The proxy creates new arrays and objects only for the paths that are modified.

Visualization

Tap to expand

Understanding the Visualization

Original Object Tree

Start with the original immutable object structure

Proxy Wrapper

Wrap the object in a Proxy that intercepts all property access

Mutation Detection

When a property is modified, create a copy-on-write for that path

Structural Sharing

Unchanged parts of the object tree are shared between original and result

Key Takeaway

🎯 Key Insight: JavaScript Proxy enables transparent immutability by intercepting mutations and applying copy-on-write semantics, creating efficient immutable updates with minimal memory overhead.

Time & Space Complexity

Time Complexity

⏱️

O(m * log d)

Where m is the number of mutations and d is the average depth. Log factor comes from path traversal optimization.

⚡ Linearithmic

Space Complexity

O(m)

Only allocates memory for actually modified objects plus minimal proxy overhead.

✓ Linear Space

Constraints

The input object will be a valid JSON object or array
The mutator function will always return undefined
The mutator will never access non-existent keys
The mutator will never delete keys or call methods on objects
The original object must never be modified
Maximum object depth: 100 levels
Maximum number of properties per object: 1000

Asked in

f Meta 45 G Google 38 N Netflix 32 A Airbnb 28

The optimal solution uses a Copy-on-Write Proxy approach that intercepts property access and modifications through JavaScript's Proxy API. The key insight is to lazily copy objects only when they're actually modified, creating a tree of minimal changes while sharing unchanged references. This provides O(m) space complexity where m is the number of mutations, rather than O(n) for the entire object size.

Common Approaches

Approach	Time	Space	Notes
✓ Change Tracking with Proxy	O(m + d)	O(m + d)	Use Proxy to track changes, then selectively copy only modified paths
Deep Clone + Direct Mutation	O(n)	O(n)	Create a full deep copy of the object and apply mutations directly
Copy-on-Write Proxy (Optimal)	O(m * log d)	O(m)	Use Proxy with lazy copy-on-write strategy for maximum efficiency

Change Tracking with Proxy — Algorithm Steps

Create a Proxy that intercepts all property access and modifications
Track the paths that are being modified during mutator execution
After mutator completes, create new object copying only changed paths
Share references to unchanged nested objects for efficiency

Visualization

Tap to expand

Step-by-Step Walkthrough

Proxy Creation

Create proxy that intercepts all property access

Track Changes

Record which paths are modified during mutator execution

Selective Copy

Create new objects only for changed paths

Structural Sharing

Reuse unchanged objects from original

Code -

solution.c — C

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

// C implementation is very complex for this approach
// due to lack of dynamic typing and proxy mechanisms

typedef struct {
    void* obj;
    void* changes;
    size_t size;
} ImmutableHelper;

ImmutableHelper* create_helper(void* obj, size_t size) {
    ImmutableHelper* helper = malloc(sizeof(ImmutableHelper));
    helper->obj = obj;
    helper->size = size;
    helper->changes = malloc(size); // Simplified change tracking
    return helper;
}

void* produce(ImmutableHelper* helper, void (*mutator)(void*)) {
    // Simplified two-pass approach
    void* proxy = malloc(helper->size);
    memcpy(proxy, helper->obj, helper->size);
    
    mutator(proxy);
    
    return proxy;
}

Time & Space Complexity

Time Complexity

⏱️

O(m + d)

Where m is the number of mutations and d is the depth of changed paths. Much better than O(n) when few properties change.

✓ Linear Growth

Space Complexity

O(m + d)

Only allocates memory for changed paths and their ancestors, plus change tracking overhead.

✓ Linear Space

Constraints

The input object will be a valid JSON object or array
The mutator function will always return undefined
The mutator will never access non-existent keys
The mutator will never delete keys or call methods on objects
The original object must never be modified
Maximum object depth: 100 levels
Maximum number of properties per object: 1000

24.7K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Change Tracking with Proxy — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler