Form Smallest Number From Two Digit Arrays

Form Smallest Number From Two Digit Arrays - Problem

Given two arrays of unique digits nums1 and nums2, return the smallest number that contains at least one digit from each array.

The result can be formed by concatenating digits from both arrays in any order. You want to minimize the overall numerical value of the result.

Example: If nums1 = [4,1,3] and nums2 = [5,7], possible numbers include 14, 15, 17, 34, 35, 37, 41, 43, 45, 47, 51, 53, 54, 57, 71, 73, 74, 75. The smallest is 14.

Input & Output

Example 1 — No Common Digits

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

› Output: 15

💡 Note: No digits appear in both arrays. The smallest from nums1 is 1, from nums2 is 5. Between 15 and 51, we choose 15.

Example 2 — Common Digit Exists

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

› Output: 3

💡 Note: Digit 3 appears in both arrays. Since we can form a single-digit number, 3 is smaller than any 2-digit combination.

Example 3 — Multiple Common Digits

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

› Output: 2

💡 Note: Both 4 and 2 appear in both arrays. We choose the smaller common digit: 2.

Constraints

1 ≤ nums1.length, nums2.length ≤ 9
1 ≤ nums1[i], nums2[i] ≤ 9
All digits in each array are unique

Visualization

Tap to expand

Asked in

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

The key insight is to check for common digits first - if any digit appears in both arrays, it forms the smallest possible single-digit answer. Otherwise, combine the minimum digits from each array in ascending order. Best approach is Greedy with Time: O(n + m), Space: O(min(n,m)).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(n × m) Space: O(n + m)

Create every possible 1-digit and 2-digit number that uses at least one digit from each array. Compare all combinations to find the smallest numerical value.

Hash Set Optimization

⏱️ Time: O(n + m) Space: O(m)

First check for any common digits using a hash set for O(1) lookups. If found, return the minimum common digit. Otherwise, find the two smallest digits and arrange them optimally.

Optimal Greedy Solution

⏱️ Time: O(n + m) Space: O(min(n, m))

The optimal approach recognizes that we only need to consider two cases: if there's any digit common to both arrays, use the smallest one; otherwise, create the smallest 2-digit number using the minimum from each array.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: Generate all single digits that appear in both arrays
Step 2: Generate all 2-digit combinations (one from each array)
Step 3: Find the minimum among all generated numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Common

Check if any digit appears in both arrays

Generate Pairs

Create all 2-digit combinations from both arrays

Find Minimum

Compare all candidates to find smallest

Code -

solution.c — C

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

int main() {
    char line1[1000], line2[1000];
    int nums1[10], nums2[10];
    int size1 = 0, size2 = 0;
    
    // Read first array
    fgets(line1, sizeof(line1), stdin);
    const char* p = line1;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        if (*p >= '0' && *p <= '9') {
            nums1[size1++] = *p - '0';
        }
        p++;
    }
    
    // Read second array
    fgets(line2, sizeof(line2), stdin);
    p = line2;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        if (*p >= '0' && *p <= '9') {
            nums2[size2++] = *p - '0';
        }
        p++;
    }
    
    // Check for common digits (smallest first)
    for (int digit = 1; digit <= 9; digit++) {
        int found1 = 0, found2 = 0;
        for (int i = 0; i < size1; i++) {
            if (nums1[i] == digit) {
                found1 = 1;
                break;
            }
        }
        for (int i = 0; i < size2; i++) {
            if (nums2[i] == digit) {
                found2 = 1;
                break;
            }
        }
        if (found1 && found2) {
            printf("%d\n", digit);
            return 0;
        }
    }
    
    // No common digit found, find minimum from each array
    int min1 = 10, min2 = 10;
    
    for (int i = 0; i < size1; i++) {
        if (nums1[i] < min1) {
            min1 = nums1[i];
        }
    }
    
    for (int i = 0; i < size2; i++) {
        if (nums2[i] < min2) {
            min2 = nums2[i];
        }
    }
    
    // Form the smallest 2-digit number
    if (min1 < min2) {
        printf("%d%d\n", min1, min2);
    } else {
        printf("%d%d\n", min2, min1);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Generate all combinations between nums1 and nums2

✓ Linear Growth

Space Complexity

O(n + m)

Store all possible combinations before comparison

⚡ Linearithmic Space

9.0K Views

Medium Frequency

~8 min Avg. Time

324 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 - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler