Problem

Given two 0-indexed integer arrays nums1 and nums2, return a list answer of size 2 where:

  • answer[0] is a list of all distinct integers in nums1 which are not present in nums2.
  • answer[1] is a list of all distinct integers in nums2 which are not present in nums1.

Note that the integers in the lists may be returned in any order.

Examples

Example 1:

1
2
3
4
5

Input: nums1 = [1,2,3], nums2 = [2,4,6]
Output:[[1,3],[4,6]]
Explanation:
For nums1, nums1[1] = 2 is present at index 0 of nums2, whereas nums1[0] = 1 and nums1[2] = 3 are not present in nums2. Therefore, answer[0] = [1,3].
For nums2, nums2[0] = 2 is present at index 1 of nums1, whereas nums2[1] = 4 and nums2[2] = 6 are not present in nums2. Therefore, answer[1] = [4,6].

Example 2:

1
2
3
4
5

Input: nums1 = [1,2,3,3], nums2 = [1,1,2,2]
Output:[[3],[]]
Explanation:
For nums1, nums1[2] and nums1[3] are not present in nums2. Since nums1[2] == nums1[3], their value is only included once and answer[0] = [3].
Every integer in nums2 is present in nums1. Therefore, answer[1] = [].

Solution

Method 1 - Using Sets

Here is the approach:

  1. Convert Arrays to Sets: First, we convert both arrays (nums1 and nums2) into sets (set1 and set2). This step removes any duplicates from the arrays and allows for efficient look-up operations.
  2. Find Unique Elements:
    • For nums1: We find all elements that are present in set1 but not in set2. This gives us the distinct integers that are in nums1 but not in nums2.
    • For nums2: We find all elements that are present in set2 but not in set1. This gives us the distinct integers that are in nums2 but not in nums1.
  3. Return the Results: The results are returned as a list of two lists: one for the unique elements in nums1 and one for the unique elements in nums2.

Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class Solution {
    public List<List<Integer>> findDifference(int[] nums1, int[] nums2) {
        // Convert both arrays to sets to get distinct integers and for
        // efficient look-up
        Set<Integer> set1 = new HashSet<>();
        for (int num : nums1) {
            set1.add(num);
        }

        Set<Integer> set2 = new HashSet<>();
        for (int num : nums2) {
            set2.add(num);
        }

        // Find elements in set1 that are not in set2
        List<Integer> answer1 = new ArrayList<>(set1);
        answer1.removeAll(set2);

        // Find elements in set2 that are not in set1
        List<Integer> answer2 = new ArrayList<>(set2);
        answer2.removeAll(set1);

        // Return the result as a list of lists
        List<List<Integer>> answer = new ArrayList<>();
        answer.add(answer1);
        answer.add(answer2);

        return answer;
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

def findDifference(nums1, nums2):
    # Convert both lists to sets to get distinct integers and for efficient look-up
    set1 = set(nums1)
    set2 = set(nums2)

    # Find elements in set1 that are not in set2
    answer1 = list(set1 - set2)

    # Find elements in set2 that are not in set1
    answer2 = list(set2 - set1)

    # Return the result as a list of lists
    return [answer1, answer2]

Complexity

  • ⏰ Time complexity: O(m + n), where m is the length of nums1 and n is the length of nums2.
  • 🧺 Space complexity: O(m + n)