Intersection of Two Arrays II - Practice Coding Problems

Intersection of Two Arrays II - Problem

Find the common elements between two integer arrays, keeping track of how many times each element appears in both arrays. Unlike a simple set intersection, this problem requires you to preserve duplicates based on their frequency in both arrays.

Given two integer arrays nums1 and nums2, return an array containing their intersection where:

Each element appears as many times as it shows up in both arrays
If an element appears 3 times in nums1 and 2 times in nums2, it should appear 2 times in the result
The result can be returned in any order

Example: nums1 = [1,2,2,1], nums2 = [2,2] → Result: [2,2]

Input & Output

example_1.py — Python

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

› Output: [2,2]

💡 Note: Element 2 appears twice in both arrays, so it appears twice in the intersection. Element 1 appears in nums1 but not in nums2, so it's excluded from the result.

example_2.py — Python

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

› Output: [4,9]

💡 Note: Element 4 appears once in nums1 and twice in nums2, so it appears once in result. Element 9 appears once in nums1 and twice in nums2, so it appears once in result. Element 5 only appears in nums1, element 8 only appears in nums2.

example_3.py — Python

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

› Output: [1]

💡 Note: Element 1 appears once in nums1 and twice in nums2. The intersection frequency is min(1,2) = 1, so 1 appears once in the result.

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
0 ≤ nums1[i], nums2[i] ≤ 1000
Follow-up questions:
What if nums2 cannot fit in memory? Use external sorting
What if nums1 is much smaller than nums2? Build hash table from smaller array

Visualization

Tap to expand

Understanding the Visualization

Count friend's cards

First, count how many of each card your friend has

Check your cards

Go through your cards and see which ones your friend also has

Make the trade

For each match, trade one copy and reduce both counts

Key Takeaway

🎯 Key Insight: Intersection frequency = min(your_count, friend_count) for each card type

Asked in

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

The optimal approach is the hash table method with O(n + m) time complexity. Build a frequency map from one array, then iterate through the other array to find matches. This efficiently handles duplicates by tracking element counts and ensures each intersection element appears the correct number of times.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Sorted Arrays)	O(n log n + m log m)	O(1)	Sort both arrays and use two pointers to find common elements efficiently
Brute Force (Nested Loops)	O(n × m)	O(m)	For each element in nums1, search through nums2 and collect matches
Two-Pass Hash Table	O(n + m)	O(min(n, m))	Count frequencies in nums2, then iterate through nums1 to find matches

Two Pointers (Sorted Arrays) — Algorithm Steps

Sort both nums1 and nums2 arrays
Initialize two pointers, one for each array, starting at index 0
Compare elements at both pointers
If equal: add to result and advance both pointers
If nums1[i] < nums2[j]: advance pointer i
If nums1[i] > nums2[j]: advance pointer j
Continue until one pointer reaches the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort both arrays

First sort nums1 and nums2 in ascending order

Compare elements

Use two pointers to compare current elements

Move pointers

Advance pointer(s) based on comparison result

Code -

solution.c — C

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

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

int* intersect(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    // Sort both arrays
    qsort(nums1, nums1Size, sizeof(int), compare);
    qsort(nums2, nums2Size, sizeof(int), compare);
    
    int* result = (int*)malloc(sizeof(int) * (nums1Size < nums2Size ? nums1Size : nums2Size));
    int i = 0, j = 0, k = 0;
    
    while (i < nums1Size && j < nums2Size) {
        if (nums1[i] == nums2[j]) {
            result[k++] = nums1[i];
            i++;
            j++;
        } else if (nums1[i] < nums2[j]) {
            i++;
        } else {
            j++;
        }
    }
    
    *returnSize = k;
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log m)

Sorting both arrays dominates: O(n log n) + O(m log m), then O(n + m) for two-pointer traversal

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space if we sort in-place (excluding output array)

✓ Linear Space

142.8K Views

High Frequency

~15 min Avg. Time

3.2K 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 Pointers (Sorted Arrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler