Form Smallest Number From Two Digit Arrays

Form Smallest Number From Two Digit Arrays - Problem

You're given two arrays of unique digits nums1 and nums2. Your task is to find the smallest possible number that contains at least one digit from each array.

The key insight is that we want the smallest number, so we should prioritize:

Single-digit numbers over multi-digit numbers
Smaller digits over larger digits
When forming multi-digit numbers, place the smaller digit first

Example: If nums1 = [4, 1, 3] and nums2 = [5, 7], we could form numbers like 45, 15, 47, etc. The smallest would be 15.

Input & Output

example_1.py — Basic Case

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

› Output: 15

💡 Note: No common digits exist. The smallest two-digit number is formed by taking min(nums1)=1 and min(nums2)=5, giving us min(15, 51) = 15.

example_2.py — Common Digit

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

› Output: 3

💡 Note: Both arrays contain digit 3, so the smallest possible number is the single digit 3.

example_3.py — Multiple Common Digits

$ Input: nums1 = [6,8,4,2], nums2 = [4,9,2,3]

› Output: 2

💡 Note: Arrays share digits 4 and 2. The minimum common digit is 2, which gives us the smallest possible number.

Visualization

Tap to expand

Understanding the Visualization

Check for Shared Jersey Numbers

First priority: if any players from both teams have the same jersey number, that's our single-digit team number

Find Team Captains (Minimum Numbers)

If no shared numbers, identify the player with the lowest jersey number from each team

Form Optimal Team Number

Arrange the two captain numbers to create the smallest possible two-digit team number

Tournament Ready!

The resulting number gives us the best possible seeding position

Key Takeaway

🎯 Key Insight: Single-digit solutions (common elements) always beat two-digit solutions, so check for intersections first!

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through each array to create sets and find minimums

✓ Linear Growth

Space Complexity

O(n + m)

Space for two hash sets to store unique digits

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 9
1 ≤ nums1[i], nums2[i] ≤ 9
All digits in each array are unique
Arrays contain only single digits (0-9)

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses hash sets to efficiently check for common digits first (giving single-digit solutions), and if none exist, directly computes the minimum two-digit number using the minimum elements from each array. Time complexity: O(n + m), Space complexity: O(n + m).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(n × m)	O(n × m)	Generate all possible numbers from both arrays and find the minimum
Optimized Hash Set Approach	O(n + m)	O(n + m)	Use hash sets to quickly find intersections and minimum values

Brute Force (Generate All Combinations) — Algorithm Steps

Check for common digits between arrays (single-digit solutions)
Generate all two-digit numbers: digit from nums1 + digit from nums2
Generate all two-digit numbers: digit from nums2 + digit from nums1
Find and return the minimum among all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Common Digits

First check if arrays share any digits for single-digit solution

Generate Forward Combinations

Create numbers with nums1 digits first, nums2 digits second

Generate Reverse Combinations

Create numbers with nums2 digits first, nums1 digits second

Find Minimum

Select the smallest number from all combinations

Code -

solution.c — C

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

int minimumNumber(int* nums1, int nums1Size, int* nums2, int nums2Size) {
    // Check for common digits
    int minCommon = INT_MAX;
    int hasCommon = 0;
    
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            if (nums1[i] == nums2[j]) {
                hasCommon = 1;
                if (nums1[i] < minCommon) {
                    minCommon = nums1[i];
                }
            }
        }
    }
    
    if (hasCommon) return minCommon;
    
    // Generate all combinations
    int minResult = INT_MAX;
    
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            int candidate1 = nums1[i] * 10 + nums2[j];
            int candidate2 = nums2[j] * 10 + nums1[i];
            
            if (candidate1 < minResult) minResult = candidate1;
            if (candidate2 < minResult) minResult = candidate2;
        }
    }
    
    return minResult;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

We check each digit in nums1 against each digit in nums2 for combinations

✓ Linear Growth

Space Complexity

O(n × m)

We store all possible number combinations in the worst case

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 9
1 ≤ nums1[i], nums2[i] ≤ 9
All digits in each array are unique
Arrays contain only single digits (0-9)

23.1K Views

Medium Frequency

~8 min Avg. Time

847 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 (Generate All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler