Two Out of Three - Practice Coding Problems

Two Out of Three - Problem

Given three integer arrays nums1, nums2, and nums3, return a distinct array containing all the values that are present in at least two out of the three arrays. You may return the values in any order.

Input & Output

Example 1 — 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.

Example 2 — No Overlap

$ 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.

Example 3 — Single Array Only

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

› Output: []

💡 Note: No value appears in at least two arrays, so the result is empty.

Constraints

1 ≤ nums1.length, nums2.length, nums3.length ≤ 100
1 ≤ nums1[i], nums2[j], nums3[k] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input

Three integer arrays with potentially overlapping values

Process

Identify values appearing in 2 or more arrays

Output

Return distinct values meeting the criteria

Key Takeaway

🎯 Key Insight: Use hash maps to efficiently track which arrays contain each value

Asked in

G Google 12 a Amazon 8 M Meta 6 M Microsoft 4

The key insight is to track which arrays contain each value rather than counting occurrences. Best approach uses a frequency count map that maps each value to the set of arrays containing it. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Frequency Count Map	O(n)	O(n)	Track which arrays each value appears in using a frequency map
Brute Force with Nested Loops	O(n²)	O(n)	Check each value against all three arrays manually
Two-Pass Hash Map	O(n)	O(n)	First pass counts occurrences, second pass collects results

Frequency Count Map — Algorithm Steps

Step 1: Create a map where each value tracks which arrays contain it
Step 2: Iterate through each array and mark array presence for each value
Step 3: Collect values that appear in 2 or more arrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Values

Create map tracking array membership

Process Arrays

Mark which arrays contain each value

Filter

Collect values with 2+ array memberships

Code -

solution.c — C

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

struct ValueTracker {
    int value;
    int arrays[3];  // Track which arrays contain this value
    int arrayCount;
};

int* solution(int* nums1, int size1, int* nums2, int size2, int* nums3, int size3, int* returnSize) {
    struct ValueTracker* tracker = malloc(1000 * sizeof(struct ValueTracker));
    int trackerCount = 0;
    
    // Process nums1
    for (int i = 0; i < size1; i++) {
        int found = -1;
        for (int j = 0; j < trackerCount; j++) {
            if (tracker[j].value == nums1[i]) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            tracker[trackerCount].value = nums1[i];
            memset(tracker[trackerCount].arrays, 0, sizeof(tracker[trackerCount].arrays));
            tracker[trackerCount].arrays[0] = 1;
            tracker[trackerCount].arrayCount = 1;
            trackerCount++;
        } else if (!tracker[found].arrays[0]) {
            tracker[found].arrays[0] = 1;
            tracker[found].arrayCount++;
        }
    }
    
    // Process nums2
    for (int i = 0; i < size2; i++) {
        int found = -1;
        for (int j = 0; j < trackerCount; j++) {
            if (tracker[j].value == nums2[i]) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            tracker[trackerCount].value = nums2[i];
            memset(tracker[trackerCount].arrays, 0, sizeof(tracker[trackerCount].arrays));
            tracker[trackerCount].arrays[1] = 1;
            tracker[trackerCount].arrayCount = 1;
            trackerCount++;
        } else if (!tracker[found].arrays[1]) {
            tracker[found].arrays[1] = 1;
            tracker[found].arrayCount++;
        }
    }
    
    // Process nums3
    for (int i = 0; i < size3; i++) {
        int found = -1;
        for (int j = 0; j < trackerCount; j++) {
            if (tracker[j].value == nums3[i]) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            tracker[trackerCount].value = nums3[i];
            memset(tracker[trackerCount].arrays, 0, sizeof(tracker[trackerCount].arrays));
            tracker[trackerCount].arrays[2] = 1;
            tracker[trackerCount].arrayCount = 1;
            trackerCount++;
        } else if (!tracker[found].arrays[2]) {
            tracker[found].arrays[2] = 1;
            tracker[found].arrayCount++;
        }
    }
    
    int* result = malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < trackerCount; i++) {
        if (tracker[i].arrayCount >= 2) {
            result[(*returnSize)++] = tracker[i].value;
        }
    }
    
    free(tracker);
    return result;
}

int main() {
    int nums1[] = {1,1,3,2};
    int nums2[] = {2,3};
    int nums3[] = {3};
    
    int returnSize;
    int* result = solution(nums1, 4, nums2, 2, nums3, 1, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all elements with O(1) hash operations

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n unique values with their array counts

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~15 min Avg. Time

842 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

Constraints

Visualization

Related Problems

Common Approaches

Frequency Count Map — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler