## Description

https://leetcode.com/problems/intersection-of-two-arrays-ii/

Given two integer arrays `nums1`

and `nums2`

, return *an array of their intersection*. Each element in the result must appear as many times as it shows in both arrays and you may return the result in **any order**.

**Example 1:**

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

**Example 2:**

Input:nums1 = [4,9,5], nums2 = [9,4,9,8,4]Output:[4,9]Explanation:[9,4] is also accepted.

**Constraints:**

`1 <= nums1.length, nums2.length <= 1000`

`0 <= nums1[i], nums2[i] <= 1000`

**Follow up:**

- What if the given array is already sorted? How would you optimize your algorithm?
- What if
`nums1`

‘s size is small compared to`nums2`

‘s size? Which algorithm is better? - What if elements of
`nums2`

are stored on disk, and the memory is limited such that you cannot load all elements into the memory at once?

## Explanation

use a hashmap to check intersections

## Python Solution

```
class Solution:
def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
results = []
counter1 = {}
for num in nums1:
counter1[num] = counter1.get(num, 0) + 1
counter2 = {}
for num in nums2:
counter2[num] = counter2.get(num, 0) + 1
for key, value in counter1.items():
if key not in counter2:
continue
else:
results += [key] * min(value, counter2[key])
return results
```

- Time complexity: O(
*n*+*m*), where n and m are the lengths of the arrays. We iterate through the first, and then through the second array; insert and lookup operations in the hash map take a constant time. - Space complexity: O(min(
*n*,*m*)). We use a hash map to store numbers (and their counts) from the smaller array.