Intersection of Multiple Arrays

Intersection of Multiple Arrays - Problem

Given a 2D integer array nums where nums[i] is a non-empty array of distinct positive integers, return the list of integers that are present in each array of nums sorted in ascending order.

Each sub-array contains only distinct positive integers, and we need to find the intersection of all arrays - the numbers that appear in every single array.

Input & Output

Example 1 — Basic Case

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

› Output: [3,4]

💡 Note: Numbers 3 and 4 appear in all three arrays: [3,1,2,4,5] contains 3,4; [1,2,3,4] contains 3,4; [3,4,5,6] contains 3,4

Example 2 — Single Element

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

› Output: []

💡 Note: No numbers appear in both arrays - first array has [1,2,3] and second has [4,5,6] with no overlap

Example 3 — All Same

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

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

💡 Note: Both arrays are identical, so all elements [1,2,3,4,5] appear in every array

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i].length ≤ 1000
1 ≤ nums[i][j] ≤ 1000
All the values of nums[i] are unique

Visualization

Tap to expand

Asked in

a Amazon 25 f Facebook 18 G Google 12

The key insight is to count how many arrays each number appears in - numbers in the intersection must appear exactly as many times as there are arrays. Best approach is frequency counting with Time: O(n × k + r log r), Space: O(u) where n=number of arrays, k=average array size, r=result size, u=unique numbers.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check Each Number

⏱️ Time: O(n × m × k) Space: O(1)

Take the first array as reference, then for each number in it, iterate through all other arrays to verify the number exists in each one. Only include numbers that appear in every array.

Frequency Counting

⏱️ Time: O(n × k + r log r) Space: O(u)

Use a hash map to count how many arrays each number appears in. A number is in the intersection if its count equals the total number of arrays. This avoids redundant searches.

Set Intersection

⏱️ Time: O(n × k) Space: O(k)

Convert the first array to a set, then iteratively intersect it with each subsequent array. This progressively narrows down the common elements, eliminating elements that don't appear in every array.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

bool* solution(int* candies, int candiesSize, int extraCandies, int* returnSize) {
    *returnSize = candiesSize;
    
    int maxCandies = candies[0];
    for (int i = 1; i < candiesSize; i++) {
        if (candies[i] > maxCandies) {
            maxCandies = candies[i];
        }
    }
    
    bool* result = (bool*)malloc(candiesSize * sizeof(bool));
    for (int i = 0; i < candiesSize; i++) {
        result[i] = candies[i] + extraCandies >= maxCandies;
    }
    
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int candies[100];
    int size = 0;
    
    // Skip the opening bracket
    char* ptr = line + 1;
    char* token = strtok(ptr, ",]");
    
    while (token != NULL && strchr(token, ']') == NULL) {
        candies[size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    // Handle the last token that might contain the closing bracket
    if (token != NULL) {
        char* bracket_pos = strchr(token, ']');
        if (bracket_pos != NULL) {
            *bracket_pos = '\0';
        }
        if (strlen(token) > 0) {
            candies[size++] = atoi(token);
        }
    }
    
    int extraCandies;
    scanf("%d", &extraCandies);
    
    int returnSize;
    bool* result = solution(candies, size, extraCandies, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%s", result[i] ? "true" : "false");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

23.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