Differences Between Two Objects - Practice Coding Problems

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

Understanding the Visualization

Input Objects

Two nested objects or arrays to compare

Deep Comparison

Recursively compare each common property

Difference Object

Result containing only changed values as [old, new] arrays

Key Takeaway

🎯 Key Insight: Only compare common keys and represent differences as [old_value, new_value] arrays

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

Approach	Time	Space	Notes
✓ Brute Force Recursive Comparison	O(n)	O(d)	Recursively compare all properties and build difference object
Optimized Depth-First Traversal	O(n)	O(d + m)	Efficient single-pass recursive comparison with early termination

Brute Force Recursive Comparison — Algorithm Steps

Step 1: Check if both values are objects/arrays
Step 2: For primitives, return difference array if different
Step 3: For objects, recursively compare each common key
Step 4: Return object only if it has differences

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Comparison

Begin with root objects obj1 and obj2

Compare Keys

For each common key, recursively compare values

Build Result

Collect differences as [old_val, new_val] arrays

Code -

solution.c — C

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

// Note: C doesn't have native JSON support, this is a simplified version
char* solution(char* obj1_str, char* obj2_str) {
    char* result = malloc(1000);
    if (strcmp(obj1_str, obj2_str) != 0) {
        sprintf(result, "{\"difference\":\"[%s,%s]\"}", obj1_str, obj2_str);
    } else {
        strcpy(result, "{}");
    }
    return result;
}

int main() {
    char obj1_str[1000], obj2_str[1000];
    fgets(obj1_str, sizeof(obj1_str), stdin);
    fgets(obj2_str, sizeof(obj2_str), stdin);
    
    // Remove newlines
    obj1_str[strcspn(obj1_str, "\n")] = 0;
    obj2_str[strcspn(obj2_str, "\n")] = 0;
    
    char* result = solution(obj1_str, obj2_str);
    printf("%s\n", result);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Visit each key-value pair once, where n is total number of properties

✓ Linear Growth

Space Complexity

O(d)

Recursion stack depth d plus space for result object

✓ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Recursive Comparison — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler