Minimum Common Value - Practice Coding Problems

Minimum Common Value - Problem

Given two integer arrays nums1 and nums2, sorted in non-decreasing order, return the minimum integer common to both arrays. If there is no common integer amongst nums1 and nums2, return -1.

Note that an integer is said to be common to nums1 and nums2 if both arrays have at least one occurrence of that integer.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: The smallest element common to both arrays is 2, so we return 2.

Example 2 — No Common Elements

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

› Output: 2

💡 Note: Common elements are 2 and 3. The minimum is 2.

Example 3 — No Common Elements

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

› Output: -1

💡 Note: No elements are common to both arrays, so 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

Input Arrays

Two sorted arrays nums1 and nums2

Find Common

Identify elements present in both arrays

Return Minimum

Return the smallest common element

Key Takeaway

🎯 Key Insight: Since arrays are sorted, the first common element found using two pointers is guaranteed to be the minimum

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is to leverage the fact that both arrays are sorted. The optimal two-pointers approach allows us to find the minimum common value in a single pass through both arrays. Time: O(n+m), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers - Optimal Solution	O(n+m)	O(1)	Use two pointers to traverse both sorted arrays simultaneously
Brute Force - Nested Loops	O(n×m)	O(1)	Check every element in nums1 against every element in nums2
Hash Map - Store First Array	O(n+m)	O(n)	Store nums1 in hash set, then check nums2 for matches

Two Pointers - Optimal Solution — Algorithm Steps

Initialize two pointers at start of both arrays
Compare elements at current pointers
If equal, found common value; if not equal, advance pointer with smaller value

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start pointers at beginning of both arrays

Compare

If equal, found answer; if not, advance smaller pointer

Result

First match is minimum due to sorted order

Code -

solution.c — C

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

int solution(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 common element is minimum due to sorted arrays
        } else if (nums1[i] < nums2[j]) {
            i++;
        } else {
            j++;
        }
    }
    
    return -1;
}

int main() {
    char line1[1000], line2[1000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nums1[100], nums2[100];
    int nums1Size = 0, nums2Size = 0;
    
    // Parse first array
    char* token = strtok(line1 + 1, ",]");
    while (token != NULL) {
        nums1[nums1Size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    // Parse second array
    token = strtok(line2 + 1, ",]");
    while (token != NULL) {
        nums2[nums2Size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    printf("%d\n", solution(nums1, nums1Size, nums2, nums2Size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n+m)

Single pass through both arrays, each element visited at most once

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables, no extra data structures

✓ Linear Space

23.5K Views

Medium Frequency

~10 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

Two Pointers - Optimal Solution — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler