Make Object Immutable

Make Object Immutable - Problem

JavaScript Medium

Write a function that takes an object obj and returns a new immutable version of this object. An immutable object is an object that can't be altered and will throw an error if any attempt is made to alter it.

There are three types of error messages that can be produced from this new object:

Attempting to modify a key on the object will result in this error message: Error Modifying: ${key}
Attempting to modify an index on an array will result in this error message: Error Modifying Index: ${index}
Attempting to call a method that mutates an array will result in this error message: Error Calling Method: ${methodName}

You may assume the only methods that can mutate an array are ['pop', 'push', 'shift', 'unshift', 'splice', 'sort', 'reverse'].

obj is a valid JSON object or array, meaning it is the output of JSON.parse().

Note: A string literal should be thrown, not an Error.

Input & Output

Example 1 — Object Property Modification

$ Input: obj = {"name": "John", "age": 30}

› Output: Attempting obj.name = "Jane" throws "Error Modifying: name"

💡 Note: The immutable object prevents property modification and throws the specific error message

Example 2 — Array Index Modification

$ Input: obj = [1, 2, 3]

› Output: Attempting obj[0] = 5 throws "Error Modifying Index: 0"

💡 Note: Array index modifications are blocked with index-specific error message

Example 3 — Array Method Call

$ Input: obj = [1, 2, 3]

› Output: Attempting obj.push(4) throws "Error Calling Method: push"

💡 Note: Mutating array methods are overridden to throw method-specific errors

Constraints

obj is a valid JSON value
obj can be an object, array, or primitive value
All nested structures must be made immutable
Must throw string literals, not Error objects

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 M Microsoft 15

The key insight is using JavaScript Proxy to intercept all property access and modification attempts. The optimal approach creates recursive Proxy wrappers that throw specific error messages for different modification types. Time: O(n), Space: O(n)

Common Approaches

✓ Object.freeze Approach

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

Apply Object.freeze to the object and all nested objects/arrays. Override array mutating methods to throw errors with custom messages.

Proxy-based Immutability

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

Create a Proxy that intercepts all property access, modification attempts, and method calls. Provide custom error messages for different types of modifications.

Object.freeze Approach — Algorithm Steps

Step 1: Recursively freeze all nested objects and arrays
Step 2: Override array mutating methods to throw custom errors
Step 3: Return the frozen object

Visualization

Tap to expand

Step-by-Step Walkthrough

Input Object

Original mutable object

Apply Freeze

Recursively freeze all properties

Immutable Result

Object throws errors on modification

Code -

solution.c — C

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

int kadane(int* arr, int n) {
    if (n == 0) return INT_MIN;
    int maxSum = arr[0];
    int currSum = arr[0];
    for (int i = 1; i < n; i++) {
        currSum = (currSum + arr[i] > arr[i]) ? currSum + arr[i] : arr[i];
        maxSum = (currSum > maxSum) ? currSum : maxSum;
    }
    return maxSum;
}

int solution(int* nums, int n) {
    int maxResult = kadane(nums, n);
    
    // Try removing each unique value
    for (int i = 0; i < n; i++) {
        int val = nums[i];
        
        // Check if we already processed this value
        int alreadyProcessed = 0;
        for (int j = 0; j < i; j++) {
            if (nums[j] == val) {
                alreadyProcessed = 1;
                break;
            }
        }
        if (alreadyProcessed) continue;
        
        int* filtered = malloc(n * sizeof(int));
        int filteredSize = 0;
        
        for (int j = 0; j < n; j++) {
            if (nums[j] != val) {
                filtered[filteredSize++] = nums[j];
            }
        }
        
        if (filteredSize > 0) {
            int result = kadane(filtered, filteredSize);
            if (result > maxResult) {
                maxResult = result;
            }
        }
        
        free(filtered);
    }
    
    return maxResult;
}

int main() {
    char line[100000];
    if (fgets(line, sizeof(line), stdin) == NULL) return 1;
    
    // Parse JSON array [a,b,c,d]
    int nums[10000];
    int n = 0;
    
    char* p = line;
    while (*p && *p != '[') p++;  // Find opening bracket
    if (*p) p++;  // Skip '['
    
    while (*p && *p != ']') {
        while (*p && (*p == ' ' || *p == '\t' || *p == '\n')) p++;  // Skip whitespace
        if (*p && *p != ']' && *p != ',') {
            int val = 0;
            int sign = 1;
            if (*p == '-') {
                sign = -1;
                p++;
            }
            while (*p >= '0' && *p <= '9') {
                val = val * 10 + (*p - '0');
                p++;
            }
            nums[n++] = sign * val;
        }
        while (*p && *p != ',' && *p != ']') p++;  // Skip to next comma or end
        if (*p == ',') p++;  // Skip comma
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each property once in the object tree

✓ Linear Growth

Space Complexity

O(1)

Only modifies existing object structure

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

890 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

Object.freeze Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler