Find Common Elements Between Two Arrays - Practice Coding Problems

Find Common Elements Between Two Arrays - Problem

You are given two integer arrays nums1 and nums2 of sizes n and m, respectively.

Your task is to find how many elements from each array exist in the other array. More specifically:

answer1: Count how many indices i exist such that nums1[i] can be found somewhere in nums2
answer2: Count how many indices i exist such that nums2[i] can be found somewhere in nums1

Return the results as [answer1, answer2].

Note: We're counting indices, not unique elements. If an element appears multiple times in an array, each occurrence is counted separately if it exists in the other array.

Example: If nums1 = [4,3,2,3,1] and nums2 = [2,2,5,2,3,6], then:

Elements 4, 3, 2, 3 from nums1 exist in nums2 (4 elements)
Elements 2, 2, 2, 3 from nums2 exist in nums1 (4 elements)
Return [4, 4]

Input & Output

example_1.py — Basic Case

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

› Output: [3,4]

💡 Note: From nums1: elements 3,2,3 exist in nums2 (3 count). From nums2: elements 2,2,2,3 exist in nums1 (4 count).

example_2.py — No Common Elements

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

› Output: [0,0]

💡 Note: No elements from nums1 exist in nums2, and no elements from nums2 exist in nums1.

example_3.py — All Elements Match

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

› Output: [3,2]

💡 Note: All elements from nums1 (2,3,2) exist in nums2. All elements from nums2 (3,2) exist in nums1.

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
1 ≤ nums1[i], nums2[i] ≤ 100
Arrays can contain duplicate elements
Count each index occurrence, not unique values

Visualization

Tap to expand

Understanding the Visualization

Build Directory

Create a quick-lookup directory (hash set) of students in one section

Count Matches

Go through the other section and count how many are in your directory

Reverse Process

Repeat the process in the opposite direction

Get Results

Return the counts from both directions

Key Takeaway

🎯 Key Insight: Using hash sets transforms O(n²) nested loops into O(n+m) linear time by replacing repeated linear searches with constant-time lookups, like having a student directory instead of scanning enrollment lists repeatedly.

Asked in

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

The optimal approach uses hash tables to achieve O(n+m) time complexity. Build hash sets for O(1) lookups instead of O(n) linear searches, transforming this from an O(n²) problem to linear time. The key insight is that repeated lookups benefit enormously from preprocessing data into hash sets.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*m)	O(1)	For each element in one array, scan the entire other array to check existence
Two-Pass Hash Table	O(n+m)	O(n+m)	Build hash sets first, then count elements that exist in the other set
One-Pass Hash Table (Optimal)	O(n+m)	O(min(n,m))	Build one hash set and count simultaneously to minimize passes through data

Brute Force (Nested Loops) — Algorithm Steps

Initialize counters answer1 = 0 and answer2 = 0
For each element in nums1, scan all elements in nums2 to check if it exists
If found, increment answer1
For each element in nums2, scan all elements in nums1 to check if it exists
If found, increment answer2
Return [answer1, answer2]

Visualization

Tap to expand

Step-by-Step Walkthrough

Check First Array

For each element in nums1, scan through all of nums2

Count Matches

Increment counter when element is found

Repeat Process

Do the same for nums2 elements against nums1

Code -

solution.c — C

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

bool contains(int* arr, int size, int target) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == target) return true;
    }
    return false;
}

int* findIntersectionValues(int* nums1, int nums1Size, int* nums2, int nums2Size, int* returnSize) {
    int* result = (int*)malloc(2 * sizeof(int));
    *returnSize = 2;
    int answer1 = 0, answer2 = 0;
    
    // Count elements in nums1 that exist in nums2
    for (int i = 0; i < nums1Size; i++) {
        if (contains(nums2, nums2Size, nums1[i])) {
            answer1++;
        }
    }
    
    // Count elements in nums2 that exist in nums1
    for (int i = 0; i < nums2Size; i++) {
        if (contains(nums1, nums1Size, nums2[i])) {
            answer2++;
        }
    }
    
    result[0] = answer1;
    result[1] = answer2;
    return result;
}

int main() {
    int nums1[] = {4,3,2,3,1};
    int nums2[] = {2,2,5,2,3,6};
    int returnSize;
    int* result = findIntersectionValues(nums1, 5, nums2, 6, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

For each of n elements in nums1, we scan m elements in nums2. Then for each of m elements in nums2, we scan n elements in nums1.

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counters, no additional data structures needed.

✓ Linear Space

32.5K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler