Intersection of Multiple Arrays - Practice Coding Problems

Intersection of Multiple Arrays - Problem

Imagine you're organizing a group project where each team member has their own list of preferred meeting days. You need to find the days that everyone is available to meet.

Given a 2D integer array nums where each nums[i] represents a non-empty array of distinct positive integers, your task is to find all integers that appear in every single array. The result should be returned as a list sorted in ascending order.

Think of it as finding the common elements across multiple sets - only the numbers that show up in all arrays make it to the final answer.

Example: If you have [[3,1,2,4,5],[1,2,3,4],[3,4,5,6]], only [3,4] appear in all three arrays.

Input & Output

example_1.py — Python

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

› Output: [3,4]

💡 Note: The numbers 3 and 4 are the only ones that appear in all three arrays. 1 and 2 are missing from the third array, 5 is missing from the second array, and 6 only appears in the third array.

example_2.py — Python

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

› Output: []

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

example_3.py — Python

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

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

💡 Note: When there's only one array, all elements in that array form the intersection by default.

Visualization

Tap to expand

Understanding the Visualization

Collect Schedules

Each team member provides their list of available meeting days

Find Overlap

Start with first person's availability, then narrow down by checking each subsequent person

Final Schedule

The remaining days are when everyone is available

Key Takeaway

🎯 Key Insight: By starting with one set and progressively intersecting with others, we efficiently find the common elements while minimizing memory usage and computation time.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Visit each element once across all arrays, with set intersection operations being efficient

✓ Linear Growth

Space Complexity

O(min(m1, m2, ..., mn))

Set size never exceeds the smallest array size due to progressive intersection

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ sum(nums[i].length) ≤ 1000
1 ≤ nums[i][j] ≤ 1000
All values in nums[i] are distinct

Asked in

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

The optimal solution uses progressive set intersection starting with the first array as candidates, then intersecting with each subsequent array. This approach achieves O(n × m) time complexity with early termination possibilities and uses minimal space proportional to the smallest array size.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n × m²)	O(1)	Check each element from first array against all other arrays
One-Pass Hash Table (Optimal)	O(n × m)	O(min(m1, m2, ..., mn))	Use set intersection starting with first array, progressively filtering
Two-Pass Hash Table	O(n × m)	O(k)	Count frequency of each element, then find elements appearing in all arrays

Brute Force (Nested Loops) — Algorithm Steps

Start with the first array as our candidate pool
For each element in the first array, check if it exists in all other arrays
Use nested loops to search through each array linearly
Add elements that appear in all arrays to result
Sort the result before returning

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Candidate

Pick an element from the first array

Linear Search

Search for this element in each subsequent array

Decision

If found in all arrays, add to result; otherwise discard

Code -

solution.c — C

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

int* intersection(int** nums, int numsSize, int* numsColSize, int* returnSize) {
    if (numsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int* result = (int*)malloc(numsColSize[0] * sizeof(int));
    int resultSize = 0;
    
    // Check each element from first array
    for (int j = 0; j < numsColSize[0]; j++) {
        int num = nums[0][j];
        int foundInAll = 1;
        
        // Check if num exists in all other arrays
        for (int i = 1; i < numsSize; i++) {
            int found = 0;
            for (int k = 0; k < numsColSize[i]; k++) {
                if (nums[i][k] == num) {
                    found = 1;
                    break;
                }
            }
            if (!found) {
                foundInAll = 0;
                break;
            }
        }
        
        if (foundInAll) {
            result[resultSize++] = num;
        }
    }
    
    // Sort result
    for (int i = 0; i < resultSize - 1; i++) {
        for (int j = i + 1; j < resultSize; j++) {
            if (result[i] > result[j]) {
                int temp = result[i];
                result[i] = result[j];
                result[j] = temp;
            }
        }
    }
    
    *returnSize = resultSize;
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × m²)

For each element in first array (m elements), we search through all other arrays (n arrays, each with m elements on average)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, not counting the output array

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ sum(nums[i].length) ≤ 1000
1 ≤ nums[i][j] ≤ 1000
All values in nums[i] are distinct

42.8K Views

Medium Frequency

~18 min Avg. Time

1.5K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler