Deep Merge of Two Objects

Deep Merge of Two Objects - Problem

JavaScript Medium

Given two JavaScript values obj1 and obj2, return a deep merged value according to these rules:

Objects: If both values are objects, the resulting object should have all keys that exist on either object. If a key belongs to both objects, recursively deep merge the two associated values. Otherwise, add the key-value pair to the resulting object.

Arrays: If both values are arrays, the resulting array should be the same length as the longer array. Apply the same merging logic as objects, but treat the array indices as keys.

Otherwise: The resulting value is obj2 (obj2 takes precedence).

You can assume obj1 and obj2 are the output of JSON.parse().

Input & Output

Example 1 — Object Merging

$ Input: obj1 = {"a": 1, "b": {"x": 2}}, obj2 = {"b": {"y": 3}, "c": 4}

› Output: {"a": 1, "b": {"x": 2, "y": 3}, "c": 4}

💡 Note: Key 'a' only in obj1, key 'c' only in obj2, key 'b' exists in both so we recursively merge the nested objects

Example 2 — Array Merging

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

› Output: [3, 4, 5]

💡 Note: Both arrays merge by index: index 0 gets obj2[0]=3, index 1 gets obj2[1]=4, index 2 only exists in obj2 so gets 5

Example 3 — Mixed Types

$ Input: obj1 = {"a": [1, 2]}, obj2 = {"a": [3, 4, 5], "b": "hello"}

› Output: {"a": [3, 4, 5], "b": "hello"}

💡 Note: Objects merge, then arrays at key 'a' merge by index giving [3, 4, 5], key 'b' only in obj2

Constraints

obj1 and obj2 are valid JSON values
Maximum depth ≤ 1000
Objects can have up to 1000 keys
Arrays can have up to 1000 elements

Visualization

Tap to expand

Asked in

M Microsoft 35 G Google 28 F Facebook 22

The key insight is to recursively check types and merge accordingly: objects merge all keys with recursive merging for conflicts, arrays merge by index up to max length, otherwise obj2 takes precedence. Best approach uses recursive traversal. Time: O(n + m), Space: O(d)

Common Approaches

✓ Dp 2d

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

Recursive Deep Merge

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

Check if both values are objects or arrays, then recursively merge their contents. For objects, iterate through all keys. For arrays, merge by index up to the longer length. Otherwise, return obj2.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int solution(int boxes[][2], int n, int portsCount, int maxBoxes, int maxWeight) {
    if (n == 0) return 0;
    
    // dp[i] = minimum trips to deliver boxes[i:]
    int* dp = (int*)malloc((n + 1) * sizeof(int));
    for (int i = 0; i < n; i++) {
        dp[i] = INT_MAX;
    }
    dp[n] = 0;
    
    for (int i = n - 1; i >= 0; i--) {
        int weight = 0;
        
        int end = (i + maxBoxes < n) ? i + maxBoxes : n;
        
        for (int j = i; j < end; j++) {
            weight += boxes[j][1];
            if (weight > maxWeight) break;
            
            // Calculate trips for this segment (sequential port changes)
            int currentPort = 0; // Starting at storage
            int trips = 0;
            
            for (int k = i; k <= j; k++) {
                if (boxes[k][0] != currentPort) {
                    trips++;
                    currentPort = boxes[k][0];
                }
            }
            
            // Add return trip unless this is the last segment
            if (j < n - 1) {
                trips++;
            }
            
            if (trips + dp[j + 1] < dp[i]) {
                dp[i] = trips + dp[j + 1];
            }
        }
    }
    
    int result = (dp[0] == INT_MAX) ? 0 : dp[0];
    free(dp);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing
    int boxes[1000][2];
    int n = 0;
    
    char *ptr = line + 1;
    while (*ptr && *ptr != ']') {
        if (*ptr == '[') {
            ptr++;
            boxes[n][0] = atoi(ptr);
            while (*ptr && *ptr != ',') ptr++;
            ptr++;
            boxes[n][1] = atoi(ptr);
            while (*ptr && *ptr != ']') ptr++;
            n++;
        }
        ptr++;
    }
    
    int portsCount, maxBoxes, maxWeight;
    scanf("%d %d %d", &portsCount, &maxBoxes, &maxWeight);
    
    int result = solution(boxes, n, portsCount, maxBoxes, maxWeight);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

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