Codestin Search App

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.

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

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.

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

Copy-on-Write Proxy (Optimal) — Algorithm Steps

Create a Proxy that intercepts property access and modification
Implement copy-on-write: copy objects only when they're modified
Handle nested objects by creating proxies recursively
Track parent-child relationships for efficient copying

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Proxy wraps original object with no copies

First Write

Copy created lazily when property is modified

Nested Access

Proxy created for nested objects on-demand

Final Result

Efficient result with minimal copying

Code -

solution.c — C

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

// C implementation is extremely complex for this approach
// as it requires dynamic typing and proxy mechanisms
// This is a highly simplified version

typedef struct {
    void* base;
    void* copies;
    int modified;
} Context;

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

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

void* produce(ImmutableHelper* helper, void (*mutator)(void*)) {
    Context context = {helper->obj, malloc(helper->size), 0};
    
    // Copy-on-write logic would be implemented here
    void* proxy = helper->obj; // Simplified
    mutator(proxy);
    
    if (context.modified) {
        return context.copies;
    }
    
    free(context.copies);
    return helper->obj;
}

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

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

Constraints

Visualization

Related Problems

Common Approaches

Copy-on-Write Proxy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler