Join Two Arrays by ID

Join Two Arrays by ID - Problem

JavaScript Medium

Given two arrays arr1 and arr2, return a new array joinedArray. All the objects in each of the two input arrays will contain an id field that has an integer value.

joinedArray is an array formed by merging arr1 and arr2 based on their id key. The length of joinedArray should be the length of unique values of id. The returned array should be sorted in ascending order based on the id key.

If a given id exists in one array but not the other, the single object with that id should be included in the result array without modification.

If two objects share an id, their properties should be merged into a single object:

If a key only exists in one object, that single key-value pair should be included in the object.
If a key is included in both objects, the value in the object from arr2 should override the value from arr1.

Input & Output

Example 1 — Basic Merge

$ Input: arr1 = [{"id":1,"x":1},{"id":2,"x":2}], arr2 = [{"id":3,"x":3}]

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

💡 Note: No overlapping IDs, so objects are combined and sorted by ID: 1, 2, 3

Example 2 — Property Override

$ Input: arr1 = [{"id":1,"x":1},{"id":2,"x":2}], arr2 = [{"id":1,"x":10,"y":20}]

› Output: [{"id":1,"x":10,"y":20},{"id":2,"x":2}]

💡 Note: ID 1 exists in both arrays. arr2 overrides x:1 with x:10 and adds y:20

Example 3 — Complex Merge

$ Input: arr1 = [{"id":2,"a":1,"b":2},{"id":3,"a":3}], arr2 = [{"id":1,"c":4},{"id":2,"a":5}]

› Output: [{"id":1,"c":4},{"id":2,"a":5,"b":2},{"id":3,"a":3}]

💡 Note: ID 2 merges: arr2's a:5 overrides arr1's a:1, but b:2 remains. Final order: 1,2,3

Constraints

1 ≤ arr1.length, arr2.length ≤ 1000
Each object contains an id field with unique integer value within its array
0 ≤ number of additional properties ≤ 10
Property values can be any valid JSON type

Visualization

Tap to expand

Asked in

G Google 32 a Amazon 28 f Facebook 25 M Microsoft 22

The optimal approach uses a hash map to merge objects by ID in O(1) time, followed by sorting. Key insight: Hash maps enable efficient property merging where arr2 values override arr1. Best time complexity: O(n log n) due to final sorting step, Space: O(n).

Common Approaches

✓ Brute Force - Nested Loop Merge

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

Iterate through arr1, and for each object, scan all of arr2 to find objects with the same ID. Merge properties when found, then handle remaining objects from arr2.

Hash Map - Two Pass

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

Use a hash map to store objects from arr1 by their ID. Then iterate through arr2, merging with existing objects or adding new ones. Finally sort the result.

One Pass Hash Map

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

Process arr1 and arr2 in a single conceptual pass, using hash map for O(1) merging. This combines the efficiency of hash maps with minimal iterations.

Brute Force - Nested Loop Merge — Algorithm Steps

Step 1: Create result array and add all objects from arr1
Step 2: For each object in arr2, search through result array for matching ID
Step 3: If match found, merge properties; otherwise add new object
Step 4: Sort result array by ID

Visualization

Tap to expand

Step-by-Step Walkthrough

Copy arr1

Add all objects from arr1 to result array

Search & Merge

For each arr2 object, scan result array for matching ID

Sort Result

Sort final array by ID in ascending order

Code -

solution.c — C

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

cJSON* solution(cJSON* arr1, cJSON* arr2) {
    cJSON* result = cJSON_CreateArray();
    
    // Add all objects from arr1 to result
    cJSON* obj1 = NULL;
    cJSON_ArrayForEach(obj1, arr1) {
        cJSON* copy = cJSON_Duplicate(obj1, 1);
        cJSON_AddItemToArray(result, copy);
    }
    
    // Process each object in arr2
    cJSON* obj2 = NULL;
    cJSON_ArrayForEach(obj2, arr2) {
        int found = 0;
        int id2 = cJSON_GetObjectItem(obj2, "id")->valueint;
        
        // Search for matching ID in result
        for (int i = 0; i < cJSON_GetArraySize(result); i++) {
            cJSON* resultObj = cJSON_GetArrayItem(result, i);
            int resultId = cJSON_GetObjectItem(resultObj, "id")->valueint;
            
            if (resultId == id2) {
                // Merge properties
                cJSON* prop = NULL;
                cJSON_ArrayForEach(prop, obj2) {
                    cJSON* key = cJSON_GetObjectItem(resultObj, prop->string);
                    if (key) cJSON_DeleteItemFromObject(resultObj, prop->string);
                    cJSON_AddItemToObject(resultObj, prop->string, cJSON_Duplicate(prop, 1));
                }
                found = 1;
                break;
            }
        }
        
        if (!found) {
            cJSON* copy = cJSON_Duplicate(obj2, 1);
            cJSON_AddItemToArray(result, copy);
        }
    }
    
    // Simple bubble sort by ID
    int size = cJSON_GetArraySize(result);
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - 1 - i; j++) {
            cJSON* a = cJSON_GetArrayItem(result, j);
            cJSON* b = cJSON_GetArrayItem(result, j + 1);
            int idA = cJSON_GetObjectItem(a, "id")->valueint;
            int idB = cJSON_GetObjectItem(b, "id")->valueint;
            
            if (idA > idB) {
                cJSON_ReplaceItemInArray(result, j, b);
                cJSON_ReplaceItemInArray(result, j + 1, a);
            }
        }
    }
    
    return result;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    cJSON* arr1 = cJSON_Parse(line1);
    cJSON* arr2 = cJSON_Parse(line2);
    
    cJSON* result = solution(arr1, arr2);
    char* output = cJSON_Print(result);
    printf("%s\n", output);
    
    cJSON_Delete(arr1);
    cJSON_Delete(arr2);
    cJSON_Delete(result);
    free(output);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n objects in arr2, we search through up to n objects in result array

⚡ Linearithmic

Space Complexity

O(n)

Result array stores up to n unique objects

⚡ Linearithmic Space

23.4K Views

High 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Nested Loop Merge — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler