JSON Deep Equal

JSON Deep Equal - Problem

JavaScript Medium

Given two values o1 and o2, return a boolean value indicating whether the two values are deeply equal.

For two values to be deeply equal, the following conditions must be met:

If both values are primitive types (string, number, boolean, null), they are deeply equal if they pass the === equality check
If both values are arrays, they are deeply equal if they have the same elements in the same order, and each element is also deeply equal according to these conditions
If both values are objects, they are deeply equal if they have the same keys, and the associated values for each key are also deeply equal according to these conditions

Note: You may assume both values are the output of JSON.parse. In other words, they are valid JSON.

Constraint: Please solve it without using lodash's _.isEqual() function.

Input & Output

Example 1 — Basic Object Comparison

$ Input: o1 = {"name": "John", "age": 25}, o2 = {"name": "John", "age": 25}

› Output: true

💡 Note: Both objects have same keys ("name", "age") with identical values ("John", 25), so they are deeply equal

Example 2 — Array with Different Elements

$ Input: o1 = [1, 2, 3], o2 = [1, 2, 4]

› Output: false

💡 Note: Arrays have same length but different elements at index 2: 3 ≠ 4, so not deeply equal

Example 3 — Nested Structure Match

$ Input: o1 = {"user": {"id": 1, "pets": ["cat"]}}, o2 = {"user": {"id": 1, "pets": ["cat"]}}

› Output: true

💡 Note: Both have same nested structure: user.id = 1 and user.pets = ["cat"] in both objects

Constraints

Both values are valid JSON (output of JSON.parse)
Objects can have nested properties of any depth
Arrays can contain mixed types (numbers, strings, objects, arrays)
Cannot use lodash's _.isEqual() function

Visualization

Tap to expand

Asked in

G Google 35 F Facebook 28 A Amazon 22 M Microsoft 18

The key insight is to use recursion to handle nested structures naturally. Compare types first, then recursively check all properties/elements. The optimized approach adds early termination and size checks for better performance. Time: O(n), Space: O(d) where n is total nodes and d is nesting depth.

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Brute Force Recursive Comparison

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

Check type equality first, then recursively compare all properties for objects or all elements for arrays. No early termination or type-specific optimizations.

Optimized Recursive with Early Termination

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

Enhance the basic approach with early termination when differences are found, better type checking, and optimized comparisons for different data types.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

long long solution(int* nums, int size) {
    if (size == 0) return 0;
    
    // Start from the rightmost element
    long long current = nums[size - 1];
    long long maxVal = current;
    
    // Process from right to left
    for (int i = size - 2; i >= 0; i--) {
        if (nums[i] <= current) {
            // Can merge: nums[i] gets absorbed into current
            current += nums[i];
        } else {
            // Cannot merge: nums[i] becomes the new current
            if (current > maxVal) {
                maxVal = current;
            }
            current = nums[i];
        }
    }
    
    // Don't forget to check the final current value
    if (current > maxVal) {
        maxVal = current;
    }
    return maxVal;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int size = 0;
    
    if (strncmp(line, "[]", 2) != 0) {
        char* token = strtok(line + 1, ",]");
        while (token != NULL) {
            nums[size++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    printf("%lld\n", solution(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

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