Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/2248.html

2248. Intersection of Multiple Arrays

  • Difficulty: Easy.
  • Related Topics: Array, Hash Table, Counting.
  • Similar Questions: Intersection of Two Arrays, Intersection of Two Arrays II, Find Smallest Common Element in All Rows, Intersection of Three Sorted Arrays, Find the Difference of Two 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.   **Example 1:

Input: nums = [[3,1,2,4,5],[1,2,3,4],[3,4,5,6]]
Output: [3,4]
Explanation: 
The only integers present in each of nums[0] = [3,1,2,4,5], nums[1] = [1,2,3,4], and nums[2] = [3,4,5,6] are 3 and 4, so we return [3,4].

Example 2:

Input: nums = [[1,2,3],[4,5,6]]
Output: []
Explanation: 
There does not exist any integer present both in nums[0] and nums[1], so we return an empty list [].

  Constraints:

  • 1 <= nums.length <= 1000

  • 1 <= sum(nums[i].length) <= 1000

  • 1 <= nums[i][j] <= 1000

  • All the values of nums[i] are unique.

Solution (Java, C++, Python)

  • class Solution {
    public List<Integer> intersection(int[][] nums) {
        List<Integer> ans = new ArrayList<>();
        int[] count = new int[1001];
        for (int[] arr : nums) {
            for (int i : arr) {
                ++count[i];
            }
        }
        for (int i = 0; i < count.length; i++) {
            if (count[i] == nums.length) {
                ans.add(i);
            }
        }
        return ans;
    }
}

############

class Solution {
    public List<Integer> intersection(int[][] nums) {
        int[] cnt = new int[1001];
        for (var arr : nums) {
            for (int x : arr) {
                ++cnt[x];
            }
        }
        List<Integer> ans = new ArrayList<>();
        for (int x = 0; x < 1001; ++x) {
            if (cnt[x] == nums.length) {
                ans.add(x);
            }
        }
        return ans;
    }
}

  • class Solution:
    def intersection(self, nums: List[List[int]]) -> List[int]:
        cnt = [0] * 1001
        for arr in nums:
            for x in arr:
                cnt[x] += 1
        return [x for x, v in enumerate(cnt) if v == len(nums)]

############

# 2248. Intersection of Multiple Arrays
# https://leetcode.com/problems/intersection-of-multiple-arrays/

class Solution:
    def intersection(self, nums: List[List[int]]) -> List[int]:
        n = len(nums)
        count = Counter()
        
        for arr in nums:
            for x in arr:
                count[x] += 1
        
        res = []
        
        for k, v in count.items():
            if v == n:
                res.append(k)
        
        return sorted(res)


  • class Solution {
public:
    vector<int> intersection(vector<vector<int>>& nums) {
        int cnt[1001]{};
        for (auto& arr : nums) {
            for (int& x : arr) {
                ++cnt[x];
            }
        }
        vector<int> ans;
        for (int x = 0; x < 1001; ++x) {
            if (cnt[x] == nums.size()) {
                ans.push_back(x);
            }
        }
        return ans;
    }
};

  • func intersection(nums [][]int) (ans []int) {
	cnt := [1001]int{}
	for _, arr := range nums {
		for _, x := range arr {
			cnt[x]++
		}
	}
	for x, v := range cnt {
		if v == len(nums) {
			ans = append(ans, x)
		}
	}
	return
}

  • function intersection(nums: number[][]): number[] {
    const cnt = new Array(1001).fill(0);
    for (const arr of nums) {
        for (const x of arr) {
            cnt[x]++;
        }
    }
    const ans: number[] = [];
    for (let x = 0; x < 1001; x++) {
        if (cnt[x] === nums.length) {
            ans.push(x);
        }
    }
    return ans;
}


  • class Solution {
    /**
     * @param Integer[][] $nums
     * @return Integer[]
     */
    function intersection($nums) {
        $rs = [];
        for ($i = 0; $i < count($nums); $i++) {
            for ($j = 0; $j < count($nums[$i]); $j++) {
                $hashtable[$nums[$i][$j]] += 1;
                if ($hashtable[$nums[$i][$j]] === count($nums)) array_push($rs, $nums[$i][$j]);
            }
        }
        sort($rs);
        return $rs;
    }
}

Explain:

nope.

Complexity:

  • Time complexity : O(n).
  • Space complexity : O(n).

All Problems

All Solutions