Differences Between Two Objects

Differences Between Two Objects - Problem

JavaScript Medium

Write a function that accepts two deeply nested objects or arrays obj1 and obj2 and returns a new object representing their differences.

The function should compare the properties of the two objects and identify any changes. The returned object should only contain keys where the value is different from obj1 to obj2. For each changed key, the value should be represented as an array [obj1 value, obj2 value].

Important: Keys that exist in one object but not in the other should not be included in the returned object. The end result should be a deeply nested object where each leaf value is a difference array.

When comparing two arrays, the indices of the arrays are considered to be their keys. You may assume that both objects are the output of JSON.parse.

Input & Output

Example 1 — Basic Object Differences

$ Input: obj1 = {"a": 5, "b": 1}, obj2 = {"a": 1, "b": 1}

› Output: {"a": [5, 1]}

💡 Note: Key 'a' has different values (5 vs 1), key 'b' has same values (1 vs 1) so not included

Example 2 — Nested Object Changes

$ Input: obj1 = {"a": {"b": 2}}, obj2 = {"a": {"b": 3}}

› Output: {"a": {"b": [2, 3]}}

💡 Note: Nested property a.b differs: 2 vs 3, so result maintains nested structure

Example 3 — Array Index Comparison

$ Input: obj1 = [1, 2, 3], obj2 = [1, 3, 3]

› Output: {"1": [2, 3]}

💡 Note: Array index 1 differs (2 vs 3), indices 0 and 2 are same so not included

Constraints

Objects are valid JSON structures
Nested depth ≤ 100 levels
Total properties ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 N Netflix 22

The key insight is to recursively compare only common keys and build the result object containing differences as [old_value, new_value] arrays. Best approach uses optimized depth-first traversal with early termination. Time: O(n), Space: O(d).

Common Approaches

✓ Frequency Count

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

Brute Force Recursive Comparison

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

Traverse both objects recursively, comparing each property. For primitive values that differ, store [obj1_value, obj2_value]. For nested objects, recursively compare and only include non-empty difference objects.

Optimized Depth-First Traversal

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

Uses depth-first traversal with optimizations: early termination for identical references, type checking before recursion, and efficient object/array handling. Minimizes object creation by only building result when differences exist.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

bool solution(int* nums, int numsSize, int k) {
    if (numsSize < k) return false;
    
    // Count frequencies using sorted array
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Check if any number appears too frequently
    int maxSubseq = (numsSize + k - 1) / k; // Maximum possible subsequences
    
    int i = 0;
    while (i < numsSize) {
        int current = nums[i];
        int count = 0;
        while (i < numsSize && nums[i] == current) {
            count++;
            i++;
        }
        
        if (count > maxSubseq) {
            return false;
        }
    }
    
    return true;
}

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 numsSize = 0;
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k;
    scanf("%d", &k);
    
    bool result = solution(nums, numsSize, k);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

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