Minimum Common Value - Practice Coding Problems

Minimum Common Value - Problem

You're tasked with finding the smallest integer that appears in both of two sorted arrays. Think of it as finding the minimum overlap between two ordered lists.

Given two integer arrays nums1 and nums2, both sorted in non-decreasing order, return the minimum integer that exists in both arrays. If no such common integer exists, return -1.

Key Points:

Both arrays are already sorted (this is a huge hint!)
We want the smallest common value, not just any common value
An integer is considered common if it appears at least once in each array

Example: If nums1 = [1,2,3] and nums2 = [2,4], the answer is 2 since it's the only (and therefore minimum) common value.

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The smallest integer common to both arrays is 2, since it appears in both nums1 and nums2.

example_2.py — Multiple Common Elements

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

› Output: 2

💡 Note: Both 2 and 3 are common to both arrays, but 2 is smaller, so we return 2.

example_3.py — No Common Elements

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

› Output: -1

💡 Note: There are no integers common to both arrays, so we return -1.

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[j] ≤ 10⁹
Both nums1 and nums2 are sorted in non-decreasing order

Visualization

Tap to expand

Understanding the Visualization

Start at the beginning

Both librarians point to their first (smallest) book ID

Compare current books

If IDs match, they found a common book! If not, whoever has the smaller ID moves to their next book

Continue until match

Keep comparing and advancing until they find a common book or run out of books

Key Takeaway

🎯 Key Insight: By leveraging the sorted property and using two pointers, we can find the minimum common element in a single pass through both arrays, making this the most efficient solution.

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses the two pointers technique to traverse both sorted arrays simultaneously in O(n+m) time and O(1) space. Since both arrays are sorted, we can intelligently advance the pointer with the smaller value until we find a match. The key insight is that the first common element we encounter will be the minimum due to the sorted property of both arrays.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n + m)	O(1)	Use two pointers to traverse both sorted arrays simultaneously
Two-Pass Hash Table	O(n + m)	O(n)	Store all elements from nums1 in a hash set, then check nums2 for matches
Binary Search Approach	O(n log m)	O(1)	For each element in nums1, binary search for it in nums2
Brute Force (Nested Loops)	O(n * m)	O(1)	Check every element in nums1 against every element in nums2

Two Pointers (Optimal) — Algorithm Steps

Initialize two pointers, one for each array, both starting at index 0
Compare the values at both pointers
If values are equal, return the value (first common value is minimum)
If nums1[i] < nums2[j], increment i (move to larger value in nums1)
If nums2[j] < nums1[i], increment j (move to larger value in nums2)
Repeat until a match is found or one array is exhausted

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize pointers

Start both pointers at the beginning of their respective arrays

Compare values

If equal, return the value. If not, advance the pointer with smaller value

Repeat until match

Continue until match found or one array is exhausted

Code -

solution.c — C

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

int findMinCommon(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    int i = 0, j = 0;
    
    while (i < nums1Size && j < nums2Size) {
        if (nums1[i] == nums2[j]) {
            return nums1[i]; // First match is minimum
        } else if (nums1[i] < nums2[j]) {
            i++; // Move to larger value in nums1
        } else {
            j++; // Move to larger value in nums2
        }
    }
    
    return -1; // No common element found
}

int main() {
    int nums1[] = {1, 2, 3};
    int nums2[] = {2, 4};
    int result = findMinCommon(nums1, 3, nums2, 2);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

In worst case, we traverse both arrays completely once

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no extra data structures

✓ Linear Space

72.3K Views

High 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

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler