Intersection of Three Sorted Arrays - Practice Coding Problems

Intersection of Three Sorted Arrays - Problem

Given three integer arrays arr1, arr2, and arr3 that are sorted in strictly increasing order, your task is to find the intersection of all three arrays.

The intersection contains only the integers that appear in all three arrays. Return these common elements as a sorted array.

For example, if arr1 = [1,2,3,4], arr2 = [2,3,4,5], and arr3 = [3,4,5,6], then the intersection would be [3,4] since only 3 and 4 appear in all three arrays.

Key Points:

All input arrays are already sorted in ascending order
Elements must appear in ALL THREE arrays to be included
Return result in sorted order (naturally sorted due to input constraints)

Input & Output

example_1.py — Basic intersection

$ Input: arr1 = [1,2,3,4], arr2 = [2,3,4,5], arr3 = [3,4,5,6]

› Output: [3,4]

💡 Note: Elements 3 and 4 appear in all three arrays. Element 1 only appears in arr1, element 2 appears in arr1 and arr2 but not arr3, elements 5 and 6 don't appear in all three arrays.

example_2.py — No common elements

$ Input: arr1 = [1,2,3], arr2 = [4,5,6], arr3 = [7,8,9]

› Output: []

💡 Note: No elements appear in all three arrays, so the intersection is empty.

example_3.py — Single element intersection

$ Input: arr1 = [1,2,3,4,5], arr2 = [1,3,5,7,9], arr3 = [1,4,7,10,13]

› Output: [1]

💡 Note: Only element 1 appears in all three arrays. Element 3 appears in arr1 and arr2 but not arr3, element 5 appears in arr1 and arr2 but not arr3, etc.

Visualization

Tap to expand

Understanding the Visualization

Start Position

All three dancers start at their first position

Find Synchronization

Check if all dancers are on the same beat

Advance Slower Dancers

Move dancers who are behind to catch up

Performance Moment

When synchronized, record the performance

Continue Dance

All dancers advance to next position

Key Takeaway

🎯 Key Insight: Like synchronized dancers, the three pointers move through sorted arrays, only "performing" (adding to result) when all three point to the same value!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially iterating through all elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, not counting output array

✓ Linear Space

Constraints

1 ≤ arr1.length, arr2.length, arr3.length ≤ 1000
1 ≤ arr1[i], arr2[i], arr3[i] ≤ 2000
All arrays are sorted in strictly increasing order
No duplicate elements within each array

Asked in

G Google 42 f Facebook 38 a Amazon 35 ⊞ Microsoft 28

The optimal solution uses three pointers to traverse all sorted arrays simultaneously in O(n) time and O(1) space. Since arrays are sorted, we can efficiently find intersections by advancing the pointer with the smallest current value until all pointers point to the same element.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every element in arr1 against every element in arr2 and arr3
Hash Set + Linear Search	O(n)	O(n)	Use hash set to store elements from first array, then find common elements
Three Pointers (Optimal)	O(n)	O(1)	Use three pointers to traverse all arrays simultaneously

Brute Force (Triple Nested Loops) — Algorithm Steps

Iterate through each element in arr1
For each element, search through arr2 to find a match
If found in arr2, search through arr3 for the same element
If found in all three arrays, add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick element from arr1

Start with first element from arr1

Search in arr2

Loop through arr2 to find matching element

Search in arr3

If found in arr2, search in arr3

Add to result

If found in all three, add to result

Code -

solution.c — C

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

int* arraysIntersection(int* arr1, int arr1Size, int* arr2, int arr2Size, int* arr3, int arr3Size, int* returnSize) {
    int* result = (int*)malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < arr1Size; i++) {
        int num1 = arr1[i];
        
        // Search for num1 in arr2
        int foundInArr2 = 0;
        for (int j = 0; j < arr2Size; j++) {
            if (arr2[j] == num1) {
                foundInArr2 = 1;
                break;
            } else if (arr2[j] > num1) {
                break;
            }
        }
        
        if (foundInArr2) {
            // Search for num1 in arr3
            for (int k = 0; k < arr3Size; k++) {
                if (arr3[k] == num1) {
                    result[(*returnSize)++] = num1;
                    break;
                } else if (arr3[k] > num1) {
                    break;
                }
            }
        }
    }
    
    return result;
}

int main() {
    int arr1[1000], arr2[1000], arr3[1000];
    int size1 = 0, size2 = 0, size3 = 0;
    
    // Simple input parsing (assumes space-separated integers)
    char line[10000];
    
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, " \n");
    while (token != NULL) {
        arr1[size1++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, " \n");
    while (token != NULL) {
        arr2[size2++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line, " \n");
    while (token != NULL) {
        arr3[size3++] = atoi(token);
        token = strtok(NULL, " \n");
    }
    
    int returnSize;
    int* result = arraysIntersection(arr1, size1, arr2, size2, arr3, size3, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially iterating through all elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, not counting output array

✓ Linear Space

Constraints

1 ≤ arr1.length, arr2.length, arr3.length ≤ 1000
1 ≤ arr1[i], arr2[i], arr3[i] ≤ 2000
All arrays are sorted in strictly increasing order
No duplicate elements within each array

42.3K Views

Medium Frequency

~15 min Avg. Time

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

Brute Force (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler