Intersection of Two Arrays - Practice Coding Problems

Intersection of Two Arrays - Problem

Given two integer arrays nums1 and nums2, find their intersection and return it as an array.

The intersection contains all elements that appear in both arrays, but each element should appear only once in the result (no duplicates). You may return the result in any order.

Example: If nums1 = [1,2,2,1] and nums2 = [2,2], the intersection is [2] because 2 appears in both arrays, but we only include it once in the result.

Input & Output

example_1.py — Basic Intersection

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

› Output: [2]

💡 Note: The only number that appears in both arrays is 2. Even though 2 appears multiple times in both arrays, we only include it once in the result.

example_2.py — Multiple Intersections

$ Input: nums1 = [4,9,5], nums2 = [9,4,9,8,4]

› Output: [9,4]

💡 Note: Both 4 and 9 appear in both arrays. The result can be in any order, so [4,9] would also be correct.

example_3.py — No Intersection

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

› Output: []

💡 Note: There are no common elements between the two arrays, so the intersection is empty.

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
0 ≤ nums1[i], nums2[i] ≤ 1000
Each result element must be unique

Visualization

Tap to expand

Understanding the Visualization

Build Hash Set

Create a hash set from nums1 for instant lookups

Check Membership

For each element in nums2, check if it exists in the hash set

Collect Matches

Add found elements to result set (automatically handles duplicates)

Return Result

Convert result set to array and return

Key Takeaway

🎯 Key Insight: Hash sets turn expensive search operations into instant lookups, making intersection finding much more efficient!

Asked in

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

The optimal approach uses a hash set for O(1) lookup time. Build a hash set from nums1, then check each element of nums2 against it. This achieves O(n + m) time complexity and is much faster than the brute force O(n × m) approach. The two pointers method after sorting is space-efficient but slower due to sorting overhead.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(m log m + n log m)	O(n + m)	Sort one array, then binary search for each element of the other array
Brute Force (Nested Loops)	O(n × m)	O(min(n,m))	For each element in first array, scan entire second array to check if it exists
Two Pointers (Sorted Arrays)	O(n log n + m log m)	O(1)	Sort both arrays and use two pointers to find common elements
Two-Pass Hash Table	O(n + m)	O(n)	First pass builds hash set from nums1, second pass checks nums2 elements

Sorting + Binary Search — Algorithm Steps

Sort nums2 array for binary search
Create a set to track processed elements and avoid duplicates
For each element in nums1, check if already processed
If not processed, perform binary search in sorted nums2
If found, add to result set and mark as processed
Convert result set to array and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort nums2

Sort the second array to enable binary search

Binary Search

For each element in nums1, binary search in sorted nums2

Found Element

When binary search succeeds, add element to result

Complete

Return all found intersection elements

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int binarySearch(int* arr, int size, int target) {
    int left = 0, right = size - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (arr[mid] == target) {
            return 1;
        } else if (arr[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return 0;
}

int* intersection(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    qsort(nums2, nums2Size, sizeof(int), compare);
    
    int* result = (int*)malloc(1000 * sizeof(int));
    int count = 0;
    
    for (int i = 0; i < nums1Size; i++) {
        if (binarySearch(nums2, nums2Size, nums1[i])) {
            // Check if already in result
            int found = 0;
            for (int j = 0; j < count; j++) {
                if (result[j] == nums1[i]) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                result[count++] = nums1[i];
            }
        }
    }
    
    *returnSize = count;
    return result;
}

int main() {
    int nums1[] = {1,2,2,1};
    int nums2[] = {2,2};
    int returnSize;
    int* result = intersection(nums1, 4, nums2, 2, &returnSize);
    for (int i = 0; i < returnSize; i++) {
        printf("%d ", result[i]);
    }
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m log m + n log m)

O(m log m) to sort nums2, O(n log m) to binary search for each element in nums1

⚡ Linearithmic

Space Complexity

O(n + m)

Space for result set and processed elements tracking

⚡ Linearithmic Space

73.4K Views

High 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

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler