Create Maximum Number

Create Maximum Number - Problem

You are given two integer arrays nums1 and nums2 of lengths m and n respectively. nums1 and nums2 represent the digits of two numbers.

You are also given an integer k. Create the maximum number of length k <= m + n from digits of the two numbers. The relative order of the digits from the same array must be preserved.

Return an array of the k digits representing the answer.

Input & Output

Example 1 — Basic Case

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

› Output: [9,8,6,5,3]

💡 Note: Taking all elements and arranging optimally: start with 9 (largest), then 8, then 6 from nums1, then 5 (can be from either), then 3. The merged result maintains relative order from each array.

Example 2 — Limited Selection

$ Input: nums1 = [6,7], nums2 = [6,0,4], k = 3

› Output: [6,7,6]

💡 Note: We need exactly 3 elements. Best strategy is to take [6,7] from nums1 and [6] from nums2. When merging, we compare [6,7] vs [6,0,4] → [6,7] is larger, so pick 6 from nums1, then 7, then 6 from nums2.

Example 3 — Small k

$ Input: nums1 = [3,9], nums2 = [8,9], k = 3

› Output: [9,8,9]

💡 Note: Take 2 from nums1 ([3,9]) and 1 from nums2 ([8] - we pick the best subsequence). Merge: compare [3,9] vs [8] → [8] > [3,9], so pick 8. Then compare [3,9] vs [] → pick 3,9. But wait, we need optimal subsequences first: [9] from nums1, [8,9] from nums2 → merge gives [9,8,9].

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000
1 ≤ nums1.length + nums2.length ≤ 2000
0 ≤ nums1[i], nums2[i] ≤ 9
1 ≤ k ≤ nums1.length + nums2.length

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 Apple 12 M Microsoft 8

The key insight is to break this into two subproblems: finding optimal subsequences from each array using monotonic stack, then merging them greedily. The optimal approach uses a greedy strategy with monotonic stack to find maximum subsequences, then merges by comparing remaining elements. Time: O(k*(m+n)), Space: O(m+n).

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(C(m,i) * C(n,k-i) * k) Space: O(2^(m+n))

For each possible split (i cards from nums1, k-i from nums2), generate all valid subsequences that maintain relative order, merge them, and find the lexicographically maximum result.

Greedy with Monotonic Stack

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

Break the problem into two parts: find the maximum subsequence of length i from each array using monotonic stack, then merge the two subsequences optimally. Try all valid splits and return the maximum result.

Brute Force - Try All Combinations — Algorithm Steps

Step 1: For each i from 0 to k, try taking i elements from nums1 and k-i from nums2
Step 2: Generate all valid subsequences of length i from nums1 and length k-i from nums2
Step 3: Merge each pair of subsequences and find the maximum result

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Decision

Try all ways to take i from nums1 and k-i from nums2

Generate Combinations

Create all valid subsequences maintaining order

Find Maximum

Merge and compare all possibilities

Code -

solution.c — C

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

int* solution(int* nums1, int nums1Size, int* nums2, int nums2Size, int k, int* returnSize) {
    *returnSize = k;
    int* result = (int*)malloc(k * sizeof(int));
    
    // Simplified brute force - try a basic greedy approach
    int maxSum = 0;
    for (int i = 0; i <= nums1Size && i <= k; i++) {
        int j = k - i;
        if (j > nums2Size) continue;
        
        // Simple selection - take first i from nums1, first j from nums2
        int* temp = (int*)malloc(k * sizeof(int));
        int idx = 0;
        for (int x = 0; x < i; x++) temp[idx++] = nums1[x];
        for (int x = 0; x < j; x++) temp[idx++] = nums2[x];
        
        // Compare with current best
        int better = 0;
        for (int x = 0; x < k; x++) {
            if (temp[x] > result[x]) { better = 1; break; }
            if (temp[x] < result[x]) break;
        }
        
        if (i == 0 && j == k || better) {
            memcpy(result, temp, k * sizeof(int));
        }
        free(temp);
    }
    
    return result;
}

int main() {
    int nums1[1000], nums2[1000];
    int nums1Size = 0, nums2Size = 0, k;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line + 1, ",]");
    while (token) {
        nums1[nums1Size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    fgets(line, sizeof(line), stdin);
    token = strtok(line + 1, ",]");
    while (token) {
        nums2[nums2Size++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    scanf("%d", &k);
    
    int returnSize;
    int* result = solution(nums1, nums1Size, nums2, nums2Size, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(C(m,i) * C(n,k-i) * k)

For each split, we generate exponential combinations and merge them

✓ Linear Growth

Space Complexity

O(2^(m+n))

Store all possible subsequences in memory

⚡ Linearithmic Space

89.0K Views

Medium Frequency

~35 min Avg. Time

1.9K 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