Merge Similar Items - Practice Coding Problems

Merge Similar Items - Problem

You're managing an inventory consolidation system for a warehouse. You have two separate lists of items from different sources, and you need to merge them intelligently!

Given two 2D integer arrays items1 and items2, where each represents a collection of items:

Each item is represented as [value, weight]
The value is a unique identifier for the item type
The weight represents the quantity/weight of that item
Important: Each value appears at most once in each array

Your Goal: Merge both inventories by combining items with the same value (adding their weights together) and return the result sorted by value in ascending order.

Example: If items1 = [[1,1],[4,5]] and items2 = [[1,8],[3,1]], then items with value 1 should be combined: weight 1 + 8 = 9.

Input & Output

example_1.py — Basic Merge

$ Input: items1 = [[1,1],[4,5],[3,8]], items2 = [[3,1],[1,5]]

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

💡 Note: Item with value 1: weight 1+5=6. Item with value 3: weight 8+1=9. Item with value 4: only in items1, weight=5. Result sorted by value.

example_2.py — No Overlap

$ Input: items1 = [[1,1],[3,2]], items2 = [[2,3],[4,2]]

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

💡 Note: No items have the same value, so we simply combine both arrays and sort by value: 1,2,3,4.

example_3.py — Complete Overlap

$ Input: items1 = [[1,3],[2,2]], items2 = [[1,2],[2,1]]

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

💡 Note: All items have matching values. Item 1: 3+2=5, Item 2: 2+1=3. Both arrays contribute to each result item.

Constraints

1 ≤ items1.length, items2.length ≤ 1000
items1[i].length == items2[i].length == 2
1 ≤ value_i, weight_i ≤ 1000
Each value in items1 and items2 is unique within its respective array

Visualization

Tap to expand

Understanding the Visualization

Receive Shipments

Two suppliers deliver their inventory lists with product codes and quantities

Create Master Ledger

Use a ledger (hash map) to track total quantities for each product code

Process First Supplier

Add all items from first supplier to the ledger

Process Second Supplier

For each item, either add quantity to existing entry or create new entry

Generate Final Catalog

Convert ledger to sorted list by product code

Key Takeaway

🎯 Key Insight: Hash maps provide O(1) lookup and update operations, making them perfect for merging operations where you need to combine values with the same key efficiently.

Asked in

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

The optimal solution uses a hash map to efficiently merge items with the same value. Process both arrays in O(n+m) time, using values as keys and accumulating weights. Finally, convert to array and sort by value for the required output format.

Common Approaches

Approach	Time	Space	Notes
✓ Hash Map (Optimal)	O(n + m + k log k)	O(k)	Use hash map to merge items in one pass through both arrays
Brute Force (Nested Loops)	O(n²)	O(n)	For each item in items1, search through items2 to find matches and merge

Hash Map (Optimal) — Algorithm Steps

Create an empty hash map to store value -> weight mappings
Iterate through items1 and add each item to the hash map
Iterate through items2, adding weights to existing entries or creating new ones
Convert hash map to list of [value, weight] pairs
Sort the result by value and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize HashMap

Create empty hash map for value->weight mapping

Process items1

Add all items from first array to hash map

Process items2

Merge items from second array, adding weights for existing keys

Convert & Sort

Convert hash map to sorted array

Code -

solution.c — C

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

typedef struct {
    int value;
    int weight;
} Item;

int compare(const void* a, const void* b) {
    Item* itemA = (Item*)a;
    Item* itemB = (Item*)b;
    return itemA->value - itemB->value;
}

int** mergeSimilarItems(int** items1, int items1Size, int* items1ColSize,
                       int** items2, int items2Size, int* items2ColSize,
                       int* returnSize, int** returnColumnSizes) {
    Item items[2001]; // Assuming values are within reasonable range
    int itemCount = 0;
    
    // Simple hash using array (assuming values are small)
    int weights[2001];
    memset(weights, 0, sizeof(weights));
    
    // Process items1
    for (int i = 0; i < items1Size; i++) {
        weights[items1[i][0]] += items1[i][1];
    }
    
    // Process items2
    for (int i = 0; i < items2Size; i++) {
        weights[items2[i][0]] += items2[i][1];
    }
    
    // Collect non-zero weights
    for (int i = 0; i <= 2000; i++) {
        if (weights[i] > 0) {
            items[itemCount].value = i;
            items[itemCount].weight = weights[i];
            itemCount++;
        }
    }
    
    // Convert to return format
    int** result = malloc(itemCount * sizeof(int*));
    *returnColumnSizes = malloc(itemCount * sizeof(int));
    
    for (int i = 0; i < itemCount; i++) {
        result[i] = malloc(2 * sizeof(int));
        result[i][0] = items[i].value;
        result[i][1] = items[i].weight;
        (*returnColumnSizes)[i] = 2;
    }
    
    *returnSize = itemCount;
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m + k log k)

O(n + m) to process both arrays + O(k log k) to sort result where k ≤ n + m unique values

⚡ Linearithmic

Space Complexity

O(k)

Space for hash map storing at most k unique values, where k ≤ n + m

✓ Linear Space

42.4K Views

Medium Frequency

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

Constraints

Visualization

Related Problems

Common Approaches

Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler