Differences Between Two Objects - Practice Coding Problems

Differences Between Two Objects - Problem

JavaScript Medium

Given two deeply nested objects or arrays obj1 and obj2, write a function that identifies and returns their differences. This is like creating a "diff" tool for JSON structures!

Your function should:

🔍 Compare all properties recursively through nested structures
📊 Return only changed values in the format [obj1Value, obj2Value]
🚫 Ignore keys that exist in only one object
🌳 Preserve the nested structure in the result

Special note: When comparing arrays, treat indices as keys. Both inputs are guaranteed to be valid JSON structures.

Example: If obj1 = {"a": 1, "b": {"x": 2}} and obj2 = {"a": 3, "b": {"x": 2}}, return {"a": [1, 3]}

Input & Output

example_1.js — Basic Object Comparison

$ Input: obj1 = {"a": 5, "b": {"c": "hello"}} obj2 = {"a": 5, "b": {"c": "world"}}

› Output: {"b": {"c": ["hello", "world"]}}

💡 Note: The property 'a' has the same value (5) in both objects, so it's not included. The nested property 'b.c' differs ('hello' vs 'world'), so we return the nested structure with the difference array.

example_2.js — Array Comparison

$ Input: obj1 = [1, 2, {"x": 3}] obj2 = [1, 4, {"x": 3}]

› Output: [null, [2, 4]]

💡 Note: Index 0 has the same value (1), so it becomes null. Index 1 differs (2 vs 4), creating a difference array. Index 2 has identical objects, so it becomes null. Trailing nulls are cleaned up in the final result.

example_3.js — No Differences

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

› Output: {}

💡 Note: All properties have identical values, so no differences are found. The function returns an empty object indicating no changes between the two objects.

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Start with two objects/arrays and prepare to compare them recursively

Type & Reference Check

Quick validation: are they the same type? Same reference? If identical, skip processing

Key/Index Iteration

For objects: iterate through keys. For arrays: iterate through indices. Only process common keys/indices

Recursive Comparison

For each common key/index, recursively compare the values. If both are objects/arrays, dive deeper

Difference Recording

When primitive values differ, record them as [obj1Value, obj2Value] in the result structure

Result Optimization

Clean up the result: remove trailing nulls from arrays, return empty object if no differences found

Key Takeaway

🎯 Key Insight: The algorithm efficiently identifies differences by traversing both structures simultaneously, creating a result that mirrors the original structure but contains only the changed values as difference arrays.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear time complexity where n is the number of differing properties. Early termination reduces constant factors significantly.

✓ Linear Growth

Space Complexity

O(d)

Space complexity depends on recursion depth d and number of actual differences, not total properties.

✓ Linear Space

Constraints

Both objects are valid JSON structures (output of JSON.parse)
Maximum nesting depth: 100 levels
Maximum number of properties per object: 10⁴
Property keys are strings with maximum length 100
Arrays are compared by index position
Only common keys/indices are considered for comparison

Asked in

f Meta 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses recursive traversal with early termination optimizations. Key insights: 1) Only compare common keys/indices, 2) Use lazy initialization to create result objects only when differences exist, 3) Implement reference equality checks for performance, 4) Clean up trailing null values in arrays. Time complexity is O(n) where n is the number of differing properties.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Recursive Traversal	O(n)	O(d)	Single-pass recursive comparison with early termination optimizations
Naive Recursive Comparison	O(n)	O(d)	Recursively compare every property without optimization

Optimized Recursive Traversal — Algorithm Steps

Quick reference equality check for identical objects
Efficient type checking with early returns
Lazy result object creation only when differences found
Optimized key iteration using modern language features
Memory-efficient recursive calls with tail recursion where possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Reference Check

Quick check if both objects are identical references

Type Validation

Efficient type checking with early returns

Lazy Initialization

Create result objects only when differences are found

Smart Iteration

Use optimized key iteration and set operations

Memory Cleanup

Clean up unused array slots and optimize memory usage

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

// Helper function to clean array of trailing nulls
void cleanArray(cJSON* arr) {
    if (!cJSON_IsArray(arr)) return;
    
    int size = cJSON_GetArraySize(arr);
    while (size > 0) {
        cJSON* last = cJSON_GetArrayItem(arr, size - 1);
        if (cJSON_IsNull(last)) {
            cJSON_DeleteItemFromArray(arr, size - 1);
            size--;
        } else {
            break;
        }
    }
}

cJSON* objDiff(cJSON* obj1, cJSON* obj2) {
    // Quick reference check
    if (obj1 == obj2) return NULL;
    
    // NULL checks
    if (!obj1 || !obj2) {
        if (!cJSON_Compare(obj1, obj2, 1)) {
            cJSON* arr = cJSON_CreateArray();
            cJSON_AddItemToArray(arr, obj1 ? cJSON_Duplicate(obj1, 1) : cJSON_CreateNull());
            cJSON_AddItemToArray(arr, obj2 ? cJSON_Duplicate(obj2, 1) : cJSON_CreateNull());
            return arr;
        }
        return NULL;
    }
    
    // Type check with early return
    if (obj1->type != obj2->type) {
        cJSON* arr = cJSON_CreateArray();
        cJSON_AddItemToArray(arr, cJSON_Duplicate(obj1, 1));
        cJSON_AddItemToArray(arr, cJSON_Duplicate(obj2, 1));
        return arr;
    }
    
    if (cJSON_IsObject(obj1)) {
        cJSON* result = NULL;
        cJSON* item1 = obj1->child;
        
        while (item1) {
            cJSON* item2 = cJSON_GetObjectItemCaseSensitive(obj2, item1->string);
            if (item2) {
                cJSON* diff = objDiff(item1, item2);
                if (diff) {
                    if (!result) result = cJSON_CreateObject();
                    cJSON_AddItemToObject(result, item1->string, diff);
                }
            }
            item1 = item1->next;
        }
        
        return result;
    } else if (cJSON_IsArray(obj1)) {
        cJSON* result = NULL;
        int size1 = cJSON_GetArraySize(obj1);
        int size2 = cJSON_GetArraySize(obj2);
        int minSize = size1 < size2 ? size1 : size2;
        
        for (int i = 0; i < minSize; i++) {
            cJSON* item1 = cJSON_GetArrayItem(obj1, i);
            cJSON* item2 = cJSON_GetArrayItem(obj2, i);
            cJSON* diff = objDiff(item1, item2);
            if (diff) {
                if (!result) {
                    result = cJSON_CreateArray();
                    // Pre-fill with nulls
                    for (int j = 0; j < minSize; j++) {
                        cJSON_AddItemToArray(result, cJSON_CreateNull());
                    }
                }
                cJSON_ReplaceItemInArray(result, i, diff);
            }
        }
        
        if (result) {
            cleanArray(result);
            if (cJSON_GetArraySize(result) == 0) {
                cJSON_Delete(result);
                result = NULL;
            }
        }
        
        return result;
    } else {
        // Primitive comparison with optimization
        if (!cJSON_Compare(obj1, obj2, 1)) {
            cJSON* arr = cJSON_CreateArray();
            cJSON_AddItemToArray(arr, cJSON_Duplicate(obj1, 1));
            cJSON_AddItemToArray(arr, cJSON_Duplicate(obj2, 1));
            return arr;
        }
    }
    
    return NULL;
}

int main() {
    char* line1 = malloc(10000);
    char* line2 = malloc(10000);
    
    if (fgets(line1, 10000, stdin)) {
        line1[strcspn(line1, "\n")] = '\0';
    }
    if (fgets(line2, 10000, stdin)) {
        line2[strcspn(line2, "\n")] = '\0';
    }
    
    cJSON* obj1 = cJSON_Parse(line1);
    cJSON* obj2 = cJSON_Parse(line2);
    
    cJSON* result = objDiff(obj1, obj2);
    if (!result) result = cJSON_CreateObject();
    
    char* output = cJSON_PrintUnformatted(result);
    printf("%s\n", output);
    
    free(line1);
    free(line2);
    cJSON_Delete(obj1);
    cJSON_Delete(obj2);
    cJSON_Delete(result);
    free(output);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear time complexity where n is the number of differing properties. Early termination reduces constant factors significantly.

✓ Linear Growth

Space Complexity

O(d)

Space complexity depends on recursion depth d and number of actual differences, not total properties.

✓ Linear Space

Constraints

Both objects are valid JSON structures (output of JSON.parse)
Maximum nesting depth: 100 levels
Maximum number of properties per object: 10⁴
Property keys are strings with maximum length 100
Arrays are compared by index position
Only common keys/indices are considered for comparison

42.3K Views

High Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Optimized Recursive Traversal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler