Two Out of Three - Practice Coding Problems

Two Out of Three - Problem

Imagine you're analyzing voting patterns across three different regions. Given three integer arrays nums1, nums2, and nums3, you need to find all the popular values that appear in at least two out of the three arrays.

Your task is to return a distinct array containing all values that have this "majority support" - appearing in 2 or more of the input arrays. The order of values in your result doesn't matter, but each value should appear only once.

Example: If nums1 = [1,1,3,2], nums2 = [2,3], and nums3 = [3], then value 2 appears in arrays 1 and 2, while 3 appears in all three arrays. So the answer is [2,3].

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,1,3,2], nums2 = [2,3], nums3 = [3]

› Output: [2,3]

💡 Note: Value 2 appears in nums1 and nums2. Value 3 appears in all three arrays. Value 1 only appears in nums1, so it's not included.

example_2.py — No Common Elements

$ Input: nums1 = [3,1], nums2 = [2,3], nums3 = [1,2]

› Output: [1,2,3]

💡 Note: Value 1 appears in nums1 and nums3. Value 2 appears in nums2 and nums3. Value 3 appears in nums1 and nums2. All values appear in at least two arrays.

example_3.py — Single Elements

$ Input: nums1 = [1,2,2], nums2 = [4,3,3], nums3 = [5]

› Output: []

💡 Note: No value appears in more than one array, so the result is empty. Each array contains completely different elements.

Visualization

Tap to expand

Understanding the Visualization

Visit Restaurant 1

Mark each unique dish with flag 🏪 (bit 1)

Visit Restaurant 2

Mark each unique dish with flag 🏬 (bit 2)

Visit Restaurant 3

Mark each unique dish with flag 🏫 (bit 4)

Find Popular Dishes

Dishes with 2+ flags are served by multiple restaurants

Key Takeaway

🎯 Key Insight: Use bit flags to efficiently track which arrays contain each element, then count bits to find elements in multiple arrays!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all three arrays to build the hash map

✓ Linear Growth

Space Complexity

O(k)

Space for hash map storing unique elements, where k is number of distinct elements

✓ Linear Space

Constraints

1 ≤ nums1.length, nums2.length, nums3.length ≤ 100
1 ≤ nums1[i], nums2[j], nums3[k] ≤ 100
All values are positive integers
Arrays can contain duplicate elements

Asked in

G Google 23 a Amazon 18 f Meta 15 ⊞ Microsoft 12

The optimal approach uses bit manipulation with hash tables to track which arrays contain each element in a single pass. By using bit flags (1, 2, 4) for each array, we can efficiently determine if an element appears in multiple arrays by counting the set bits in its mask. This gives us O(n) time complexity with minimal space overhead.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(n)	First pass counts occurrences per array, second pass finds elements in 2+ arrays
Brute Force (Nested Loops)	O(n²)	O(k)	Check each element against all other arrays using nested loops
One-Pass Hash Table (Optimal)	O(n)	O(k)	Track which arrays each element appears in using bit manipulation in a single pass

Two-Pass Hash Table — Algorithm Steps

Create sets for each input array to remove duplicates
Create a frequency map to count how many arrays contain each element
For each unique element in each array set, increment its count
Iterate through frequency map and collect elements with count >= 2
Return the result as an array

Visualization

Tap to expand

Step-by-Step Walkthrough

Create Sets

Convert arrays to sets to remove duplicates

Count Frequencies

Count how many arrays each element appears in

Filter Results

Collect elements with frequency >= 2

Code -

solution.c — C

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

#define MAX_VAL 101

int* twoOutOfThree(int* nums1, int nums1Size, int* nums2, int nums2Size, int* nums3, int nums3Size, int* returnSize) {
    // First pass: mark presence in each array
    bool present1[MAX_VAL] = {0};
    bool present2[MAX_VAL] = {0};
    bool present3[MAX_VAL] = {0};
    int count[MAX_VAL] = {0};
    
    for (int i = 0; i < nums1Size; i++) {
        present1[nums1[i]] = true;
    }
    for (int i = 0; i < nums2Size; i++) {
        present2[nums2[i]] = true;
    }
    for (int i = 0; i < nums3Size; i++) {
        present3[nums3[i]] = true;
    }
    
    // Second pass: count array appearances
    for (int i = 1; i < MAX_VAL; i++) {
        if (present1[i]) count[i]++;
        if (present2[i]) count[i]++;
        if (present3[i]) count[i]++;
    }
    
    int* result = (int*)malloc(MAX_VAL * sizeof(int));
    *returnSize = 0;
    
    for (int i = 1; i < MAX_VAL; i++) {
        if (count[i] >= 2) {
            result[(*returnSize)++] = i;
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through each array to build sets, then single pass through frequency map

✓ Linear Growth

Space Complexity

O(n)

Space for three sets plus frequency map, where n is total number of unique elements

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length, nums3.length ≤ 100
1 ≤ nums1[i], nums2[j], nums3[k] ≤ 100
All values are positive integers
Arrays can contain duplicate elements

78.4K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler