Problem Description

You are given three integer arrays: nums1, nums2, and nums3. Your task is to find all the values that appear in at least two out of these three arrays. The result should contain only distinct values (no duplicates), and you can return them in any order.

For example, if a number appears in nums1 and nums2, it should be included in the result. Similarly, if a number appears in all three arrays, it should also be included (since it appears in at least two arrays). However, if a number appears only in one array, it should not be included.

The solution approach converts each array into a set to remove duplicates within each array. Then it checks every possible integer from 1 to 100 to see if it appears in at least two of the three sets. The expression (i in s1) + (i in s2) + (i in s3) counts how many sets contain the number i (since True equals 1 and False equals 0 in Python). If this sum is greater than 1, it means the number appears in at least two arrays and should be included in the result.

Intuition

The key insight is that we need to track which numbers appear in multiple arrays, not how many times they appear within a single array. This immediately suggests using sets to eliminate duplicates within each array - if a number appears multiple times in nums1, we only care that it exists in nums1, not how many times.

Once we have sets, we need to find the intersection of at least two sets. Instead of computing pairwise intersections like (s1 ∩ s2) ∪ (s1 ∩ s3) ∪ (s2 ∩ s3), which would be complex, we can think about this problem differently: for each possible number, count how many sets contain it.

Since the problem constraints typically limit the range of values (here, numbers are between 1 and 100), we can simply check each possible value. For each number i, we check its presence in all three sets. The clever part is using boolean arithmetic: (i in s1) + (i in s2) + (i in s3) gives us a count of how many sets contain i. If this count is 2 or 3, then i appears in at least two arrays and should be included in our answer.

This approach transforms the problem from "find overlapping elements" to "count occurrences across sets," which is conceptually simpler and leads to clean, readable code.

Solution Approach

The implementation follows a straightforward approach using sets and enumeration:

1. Convert arrays to sets: First, we convert each input array into a set:

   s1, s2, s3 = set(nums1), set(nums2), set(nums3)

   This removes any duplicate values within each array, since we only care about whether a value exists in an array, not how many times it appears.

2. Enumerate possible values: Since the problem constraints indicate that values range from 1 to 100, we iterate through this range:

   for i in range(1, 101)

3. Count occurrences across sets: For each number i, we check its presence in all three sets using the expression:

   (i in s1) + (i in s2) + (i in s3)

   This leverages Python's boolean arithmetic where True equals 1 and False equals 0. The result is a count of how many sets contain the number i.

4. Filter based on count: We include i in our result only if it appears in at least two sets:

   if (i in s1) + (i in s2) + (i in s3) > 1

5. List comprehension: The entire logic is elegantly combined into a single list comprehension:

   return [i for i in range(1, 101) if (i in s1) + (i in s2) + (i in s3) > 1]

The time complexity is O(n1 + n2 + n3) for creating the sets, plus O(100) for the enumeration, which simplifies to O(n) where n is the total number of elements. The space complexity is O(n) for storing the sets.

Example Walkthrough

Let's walk through a small example to illustrate the solution approach:

Input:

• nums1 = [1, 1, 3, 2]
• nums2 = [2, 3]
• nums3 = [3]

Step 1: Convert arrays to sets

• s1 = {1, 2, 3} (duplicates removed from nums1)
• s2 = {2, 3}
• s3 = {3}

Step 2: Check each number from 1 to 100

Let's trace through the first few relevant numbers:

• i = 1:

  • (1 in s1) + (1 in s2) + (1 in s3) = True + False + False = 1 + 0 + 0 = 1
  • Count is 1, so 1 is NOT included (appears in only one array)

• i = 2:

  • (2 in s1) + (2 in s2) + (2 in s3) = True + True + False = 1 + 1 + 0 = 2
  • Count is 2, so 2 IS included (appears in nums1 and nums2)

• i = 3:

  • (3 in s1) + (3 in s2) + (3 in s3) = True + True + True = 1 + 1 + 1 = 3
  • Count is 3, so 3 IS included (appears in all three arrays)

• i = 4 through i = 100:

  • All return count of 0, so none are included

Step 3: Build result The list comprehension collects all numbers where the count > 1:

• Result: [2, 3]

Why this works:

• Number 1 only appears in nums1, so it's excluded
• Number 2 appears in both nums1 and nums2 (count = 2), so it's included
• Number 3 appears in all three arrays (count = 3), so it's included
• The duplicate 1 in nums1 doesn't affect the result since we use sets

Solution Implementation

Time and Space Complexity

The time complexity is O(n₁ + n₂ + n₃ + 100) which simplifies to O(n₁ + n₂ + n₃) since 100 is a constant. The creation of each set takes O(n₁), O(n₂), and O(n₃) time respectively. The list comprehension iterates through the range 1 to 100 (constant time), and for each number, it performs three set membership checks (each O(1) on average). Therefore, the overall time complexity is O(n₁ + n₂ + n₃).

The space complexity is O(n₁ + n₂ + n₃). This accounts for the storage required by the three sets s1, s2, and s3, which in the worst case contain all unique elements from their respective input arrays. The output list takes at most O(100) = O(1) space since there are at most 100 possible values. Therefore, the overall space complexity is O(n₁ + n₂ + n₃).

Here, n₁, n₂, n₃ are the lengths of the arrays nums1, nums2, and nums3, respectively.

Learn more about how to find time and space complexity quickly.

Common Pitfalls

1. Assuming Fixed Value Range Without Verification

The current solution assumes values are between 1 and 100, which could break if the problem constraints change or if negative numbers or values outside this range exist.

Problem Example:

nums1 = [1, 2, 200]  # Contains 200, outside assumed range
nums2 = [2, 3, 200]
nums3 = [3]
# Current solution would miss 200, even though it appears in 2 arrays

Solution: Instead of hardcoding the range, dynamically determine it from the actual values:

def twoOutOfThree(self, nums1, nums2, nums3):
    set1, set2, set3 = set(nums1), set(nums2), set(nums3)
  
    # Get all unique values across all arrays
    all_values = set1 | set2 | set3
  
    result = []
    for num in all_values:
        count = (num in set1) + (num in set2) + (num in set3)
        if count > 1:
            result.append(num)
  
    return result

2. Inefficient Set Intersection Approach

Some might attempt using set intersections directly, but this misses values that appear in exactly 2 arrays:

Incorrect Approach:

# This only finds values in ALL THREE arrays
result = set(nums1) & set(nums2) & set(nums3)  # Wrong!

Correct Alternative Using Set Operations:

def twoOutOfThree(self, nums1, nums2, nums3):
    set1, set2, set3 = set(nums1), set(nums2), set(nums3)
  
    # Find all pairwise intersections
    in_1_and_2 = set1 & set2
    in_1_and_3 = set1 & set3
    in_2_and_3 = set2 & set3
  
    # Union all pairwise intersections
    return list(in_1_and_2 | in_1_and_3 | in_2_and_3)

3. Not Handling Duplicates Within Individual Arrays

Forgetting to convert arrays to sets first could lead to incorrect counting if duplicates exist within a single array:

Problem Example:

nums1 = [1, 1, 1]  # 1 appears 3 times in nums1
nums2 = [2]
nums3 = [3]
# Without sets, might incorrectly think 1 appears in "multiple" arrays

The original solution correctly handles this by converting to sets first, ensuring each value is counted only once per array.