Find the Difference of Two Arrays - Practice Coding Problems

Find the Difference of Two Arrays - Problem

Given two integer arrays nums1 and nums2, your task is to find the unique elements that exist in one array but not in the other.

Return a list containing exactly two sublists:

First sublist: All distinct integers from nums1 that are not present in nums2
Second sublist: All distinct integers from nums2 that are not present in nums1

Think of this as finding the "difference" between two sets - what's unique to each array when compared to the other.

Note: The order of elements in the result doesn't matter, and duplicates should be removed from the output.

Input & Output

example_1.py — Basic Difference

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

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

💡 Note: Elements 1 and 3 are in nums1 but not nums2. Elements 4 and 6 are in nums2 but not nums1. Element 2 appears in both arrays so it's excluded from both results.

example_2.py — With Duplicates

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

› Output: [[3],[]]

💡 Note: Element 3 appears in nums1 but not nums2. All elements in nums2 (1 and 2) also appear in nums1, so the second result is empty. Duplicates are automatically handled.

example_3.py — No Common Elements

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

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

💡 Note: No elements are shared between the arrays, so each array's unique elements form the complete difference sets.

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
-1000 ≤ nums1[i], nums2[i] ≤ 1000
Both arrays can contain duplicate elements
Result should contain only distinct elements

Visualization

Tap to expand

Understanding the Visualization

Input Arrays

Start with two arrays that may contain duplicates

Convert to Sets

Remove duplicates by converting to hash sets

Find Differences

Use set subtraction to find unique elements

Return Results

Convert difference sets back to arrays

Key Takeaway

🎯 Key Insight: Hash sets provide O(1) lookup time, making set difference operations extremely efficient for finding unique elements between arrays.

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal solution uses hash sets to achieve O(n + m) time complexity. Convert both arrays to sets, then use set difference operations to find elements that exist in one set but not the other. This approach automatically handles duplicates and provides the cleanest, most efficient implementation.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n + m)	O(n + m)	Build hash sets first, then find differences in separate passes
Brute Force (Nested Loops)	O(n × m)	O(k)	Check each element against every element in the other array
One-Pass Hash Table (Optimal)	O(n + m)	O(n + m)	Use set difference operations for maximum efficiency

Two-Pass Hash Table — Algorithm Steps

Convert nums1 and nums2 to hash sets for fast lookups
Initialize empty result lists
First pass: iterate through nums1, add elements not in nums2 set
Second pass: iterate through nums2, add elements not in nums1 set
Return both result lists

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Hash Sets

Convert both arrays to hash sets for O(1) lookup

First Pass

Check each element in set1 against set2

Second Pass

Check each element in set2 against set1

Code -

solution.c — C

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

#define HASH_SIZE 2001
#define OFFSET 1000

bool hashSet1[HASH_SIZE] = {false};
bool hashSet2[HASH_SIZE] = {false};

int** findDifference(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize, int** returnColumnSizes) {
    // Clear hash sets
    for (int i = 0; i < HASH_SIZE; i++) {
        hashSet1[i] = hashSet2[i] = false;
    }
    
    // Build hash sets
    for (int i = 0; i < nums1Size; i++) {
        hashSet1[nums1[i] + OFFSET] = true;
    }
    for (int i = 0; i < nums2Size; i++) {
        hashSet2[nums2[i] + OFFSET] = true;
    }
    
    int** result = malloc(2 * sizeof(int*));
    *returnColumnSizes = malloc(2 * sizeof(int));
    
    result[0] = malloc(nums1Size * sizeof(int));
    result[1] = malloc(nums2Size * sizeof(int));
    
    int count1 = 0, count2 = 0;
    
    // Find differences
    for (int i = -1000; i <= 1000; i++) {
        if (hashSet1[i + OFFSET] && !hashSet2[i + OFFSET]) {
            result[0][count1++] = i;
        }
        if (hashSet2[i + OFFSET] && !hashSet1[i + OFFSET]) {
            result[1][count2++] = i;
        }
    }
    
    (*returnColumnSizes)[0] = count1;
    (*returnColumnSizes)[1] = count2;
    *returnSize = 2;
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Linear time to create sets and iterate through arrays once each

✓ Linear Growth

Space Complexity

O(n + m)

Space needed to store both input arrays as hash sets

⚡ Linearithmic Space

38.4K Views

Medium 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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler