Create Maximum Number - Practice Coding Problems

Create Maximum Number - Problem

You are tasked with creating the maximum possible number by cleverly combining digits from two separate integer arrays. Given two arrays nums1 and nums2 of lengths m and n respectively, where each element represents a single digit (0-9), you need to select exactly k digits to form the largest possible number.

Key Rules:

You must select exactly k digits total (where k ≤ m + n)
The relative order of digits from the same array must be preserved
You can choose any number of digits from each array (including zero from either)
Return the result as an array representing the maximum number

Example: If nums1 = [3,4,6,5], nums2 = [9,1,2,5,8,3], and k = 5, the answer would be [9,8,6,5,3] - we take the subsequence [6,5] from nums1 and [9,8,3] from nums2, then merge them optimally.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: We can take [6,5] from nums1 and [9,8,3] from nums2. Merging them optimally gives [9,8,6,5,3] which is the maximum possible number.

example_2.py — Take All From One

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

› Output: [6,7,6,0,4]

💡 Note: We need all 5 digits, so we take all from both arrays. The optimal merge is [6,7,6,0,4] by comparing sequences lexicographically.

example_3.py — Edge Case k=1

$ Input: nums1 = [1], nums2 = [1,1,1], k = 1

› Output: [1]

💡 Note: When k=1, we just need to find the maximum digit across both arrays, which is 1.

Time & Space Complexity

Time Complexity

⏱️

O(k * (m + n + k))

We try k+1 possible splits, and for each split we spend O(m+n) time to find max subsequences and O(k) time to merge them

✓ Linear Growth

Space Complexity

O(k)

We only need space for the result array and temporary arrays during processing

✓ Linear Space

Constraints

m == nums1.length
n == nums2.length
1 ≤ m, n ≤ 500
0 ≤ nums1[i], nums2[i] ≤ 9
1 ≤ k ≤ m + n
Follow up: Try to optimize your time and space complexity.

Asked in

The optimal solution uses a three-step greedy approach: 1) Try all valid ways to split k digits between the arrays, 2) Use monotonic stacks to find the maximum subsequence of required length from each array, and 3) Merge greedily by comparing remaining sequences lexicographically. This achieves O(k × (m + n + k)) time complexity, much better than the exponential brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Monotonic Stack (Optimal)	O(k * (m + n + k))	O(k)	Use greedy strategy with monotonic stacks to find optimal solution efficiently
Brute Force (Try All Combinations)	O(2^(m+n) * k)	O(2^(m+n) * k)	Try all possible ways to distribute k digits between the two arrays and merge them

Greedy with Monotonic Stack (Optimal) — Algorithm Steps

For each possible split i (digits from nums1) and k-i (digits from nums2)
Use monotonic stack to find maximum subsequence of length i from nums1
Use monotonic stack to find maximum subsequence of length k-i from nums2
Merge the two subsequences greedily by comparing remaining sequences
Keep track of the overall maximum result

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Strategy

Try all valid ways to distribute k digits between arrays

Monotonic Stack

Use monotonic stack to find maximum subsequence from each array

Greedy Merge

Merge subsequences by always choosing lexicographically larger sequence

Track Maximum

Keep the best result across all splits

Code -

solution.c — C

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

int* maxArray(int* nums, int numsSize, int k, int* returnSize) {
    if (k >= numsSize) {
        int* result = (int*)malloc(numsSize * sizeof(int));
        memcpy(result, nums, numsSize * sizeof(int));
        *returnSize = numsSize;
        return result;
    }
    if (k == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int* stack = (int*)malloc(numsSize * sizeof(int));
    int top = -1;
    int toDrop = numsSize - k;
    
    for (int i = 0; i < numsSize; i++) {
        while (top >= 0 && stack[top] < nums[i] && toDrop > 0) {
            top--;
            toDrop--;
        }
        stack[++top] = nums[i];
    }
    
    while (toDrop > 0) {
        top--;
        toDrop--;
    }
    
    int* result = (int*)malloc((top + 1) * sizeof(int));
    memcpy(result, stack, (top + 1) * sizeof(int));
    *returnSize = top + 1;
    
    free(stack);
    return result;
}

int isGreater(int* nums1, int size1, int* nums2, int size2) {
    for (int i = 0; i < size1 && i < size2; i++) {
        if (nums1[i] > nums2[i]) return 1;
        if (nums1[i] < nums2[i]) return 0;
    }
    return size1 > size2;
}

int* merge(int* nums1, int size1, int* nums2, int size2, int* returnSize) {
    int* result = (int*)malloc((size1 + size2) * sizeof(int));
    int i = 0, j = 0, k = 0;
    
    while (i < size1 || j < size2) {
        if (i >= size1) {
            while (j < size2) result[k++] = nums2[j++];
            break;
        } else if (j >= size2) {
            while (i < size1) result[k++] = nums1[i++];
            break;
        } else if (isGreater(nums1 + i, size1 - i, nums2 + j, size2 - j)) {
            result[k++] = nums1[i++];
        } else {
            result[k++] = nums2[j++];
        }
    }
    
    *returnSize = k;
    return result;
}

int* maxNumber(int* nums1, int nums1Size, int* nums2, int nums2Size, int k, int* returnSize) {
    int* maxResult = (int*)calloc(k, sizeof(int));
    *returnSize = k;
    
    for (int i = (k - nums2Size > 0 ? k - nums2Size : 0); 
         i <= (k < nums1Size ? k : nums1Size); i++) {
        
        int size1, size2, candidateSize;
        int* max1 = maxArray(nums1, nums1Size, i, &size1);
        int* max2 = maxArray(nums2, nums2Size, k - i, &size2);
        int* candidate = merge(max1, max2, size1, size2, &candidateSize);
        
        if (isGreater(candidate, candidateSize, maxResult, k)) {
            memcpy(maxResult, candidate, k * sizeof(int));
        }
        
        if (max1) free(max1);
        if (max2) free(max2);
        free(candidate);
    }
    
    return maxResult;
}

int main() {
    int nums1[] = {3, 4, 6, 5};
    int nums2[] = {9, 1, 2, 5, 8, 3};
    int k = 5;
    int returnSize;
    
    int* result = maxNumber(nums1, 4, nums2, 6, 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(k * (m + n + k))

We try k+1 possible splits, and for each split we spend O(m+n) time to find max subsequences and O(k) time to merge them

✓ Linear Growth

Space Complexity

O(k)

We only need space for the result array and temporary arrays during processing

✓ Linear Space

Constraints

m == nums1.length
n == nums2.length
1 ≤ m, n ≤ 500
0 ≤ nums1[i], nums2[i] ≤ 9
1 ≤ k ≤ m + n
Follow up: Try to optimize your time and space complexity.

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Greedy with Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler