Merge Two 2D Arrays by Summing Values - Practice Coding Problems

Merge Two 2D Arrays by Summing Values - Problem

You're tasked with merging two inventory lists from different warehouses! Each warehouse provides their data as a 2D array where each entry contains an [id, value] pair representing an item's ID and its quantity.

Your Mission: Combine these inventories into a single, consolidated list where:

📦 Each item ID appears exactly once
🔢 The value for each ID is the sum of quantities from both warehouses
📈 The final list is sorted by ID in ascending order
✨ If an item exists in only one warehouse, treat the other warehouse's quantity as 0

Input: Two 2D integer arrays nums1 and nums2, both already sorted by ID

Output: A merged 2D array sorted by ID with summed values

Example: If Warehouse A has [[1,2],[2,3]] and Warehouse B has [[1,4],[3,5]], the result should be [[1,6],[2,3],[3,5]]

Input & Output

example_1.py — Basic merge with overlapping IDs

$ Input: nums1 = [[1,2],[2,3],[4,5]] nums2 = [[1,4],[3,2],[4,1]]

› Output: [[1,6],[2,3],[3,2],[4,6]]

💡 Note: ID 1 appears in both arrays: 2 + 4 = 6. ID 4 appears in both arrays: 5 + 1 = 6. IDs 2 and 3 appear in only one array each, so their values remain unchanged.

example_2.py — No overlapping IDs

$ Input: nums1 = [[2,4],[3,6],[5,5]] nums2 = [[1,3],[4,3]]

› Output: [[1,3],[2,4],[3,6],[4,3],[5,5]]

💡 Note: No IDs overlap between the arrays, so we simply merge and sort all entries by ID. The result contains all unique IDs from both arrays.

example_3.py — One array empty

$ Input: nums1 = [] nums2 = [[1,1],[2,2]]

› Output: [[1,1],[2,2]]

💡 Note: When one array is empty, the result is simply the other array since there are no overlapping IDs to sum. The array is already sorted by ID.

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
nums1[i].length == nums2[i].length == 2
1 ≤ id_i, val_i ≤ 1000
Both arrays contain unique ids and are sorted in ascending order by id

Visualization

Tap to expand

Understanding the Visualization

Set up pointers

Each assistant points to the first item in their list

Compare item IDs

Look at the IDs both assistants are pointing to

Process smaller ID

If one ID is smaller, add that item to the master list and move that assistant forward

Sum equal IDs

If IDs are equal, add the item with combined quantities and move both assistants forward

Continue until done

Repeat until all items from both lists are processed

Key Takeaway

🎯 Key Insight: The two-pointer technique works perfectly here because both input arrays are already sorted, allowing us to merge them in linear time like the merge step in merge sort!

Asked in

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

The optimal solution uses two pointers to merge the sorted arrays in O(n + m) time. Since both arrays are pre-sorted by ID, we can compare current elements and process them in order, summing values when IDs match. This eliminates the need for sorting or hash tables, making it the most efficient approach with O(1) extra space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(k)	Compare every element from first array with every element from second array
Hash Table (Single Pass)	O(n + m + k log k)	O(k)	Use hash table to store all values and handle duplicates automatically
Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to merge sorted arrays in one pass like merge sort

Brute Force (Nested Loops) — Algorithm Steps

Create a result array to store merged pairs
For each [id, val] in nums1, search entire nums2 for matching id
If match found, add [id, val1 + val2] to result and mark as processed
If no match, add [id, val1] to result
Scan nums2 for unprocessed IDs and add them to result
Sort the result array by ID

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Take first element [1,2] from nums1

Search through nums2

Compare with each element in nums2 until match found

Add to result

When match found, sum values and add to result

Repeat for all elements

Continue this process for every element in nums1

Handle remaining

Add unprocessed elements from nums2 to result

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    int* arr1 = *(int**)a;
    int* arr2 = *(int**)b;
    return arr1[0] - arr2[0];
}

int** mergeArrays(int** nums1, int nums1Size, int* nums1ColSize, 
                  int** nums2, int nums2Size, int* nums2ColSize, 
                  int* returnSize, int** returnColumnSizes) {
    int** result = malloc(sizeof(int*) * (nums1Size + nums2Size));
    bool* used = calloc(nums2Size, sizeof(bool));
    *returnSize = 0;
    
    // Process nums1 and find matches in nums2
    for (int i = 0; i < nums1Size; i++) {
        int id1 = nums1[i][0], val1 = nums1[i][1];
        bool found = false;
        for (int j = 0; j < nums2Size; j++) {
            if (nums2[j][0] == id1) {
                result[*returnSize] = malloc(sizeof(int) * 2);
                result[*returnSize][0] = id1;
                result[*returnSize][1] = val1 + nums2[j][1];
                used[j] = true;
                (*returnSize)++;
                found = true;
                break;
            }
        }
        if (!found) {
            result[*returnSize] = malloc(sizeof(int) * 2);
            result[*returnSize][0] = id1;
            result[*returnSize][1] = val1;
            (*returnSize)++;
        }
    }
    
    // Add remaining elements from nums2
    for (int i = 0; i < nums2Size; i++) {
        if (!used[i]) {
            result[*returnSize] = malloc(sizeof(int) * 2);
            result[*returnSize][0] = nums2[i][0];
            result[*returnSize][1] = nums2[i][1];
            (*returnSize)++;
        }
    }
    
    // Sort by ID
    qsort(result, *returnSize, sizeof(int*), compare);
    
    *returnColumnSizes = malloc(sizeof(int) * (*returnSize));
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = 2;
    }
    
    free(used);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each element in nums1 (n elements), we scan through all of nums2 (m elements), giving us O(n×m) which is O(n²) when n ≈ m

⚠ Quadratic Growth

Space Complexity

O(k)

Only space needed is for the result array containing k unique IDs

✓ Linear Space

84.6K Views

Medium Frequency

~15 min Avg. Time

2.3K 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 Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler