# Solving Leetcode Interviews in Seconds with AI: Create Maximum Number


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "321" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> 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.   Example 1:  Input: nums1 = [3,4,6,5], nums2 = [9,1,2,5,8,3], k = 5 Output: [9,8,6,5,3]  Example 2:  Input: nums1 = [6,7], nums2 = [6,0,4], k = 5 Output: [6,7,6,0,4]  Example 3:  Input: nums1 = [3,9], nums2 = [8,9], k = 3 Output: [9,8,9]    Constraints:  m == nums1.length n == nums2.length 1 <= m, n <= 500 0 <= nums1[i], nums2[i] <= 9 1 <= k <= m + n nums1 and nums2 do not have leading zeros.  

	# Explanation
	Here's a breakdown of the solution strategy:

*   **Decomposition:** The core idea is to generate all possible candidate arrays by picking `i` digits from `nums1` and `k-i` digits from `nums2`, where `0 <= i <= k`.
*   **Monotonic Stack (Greedy):** For each possible number of digits to pick from each array, a monotonic decreasing stack is used to efficiently extract the largest possible subsequence of the desired length from that array while preserving relative order.
*   **Merge & Compare:**  The resulting subsequences are merged, and the lexicographically largest merged sequence across all combinations of `i` is selected as the final result.

*   **Time Complexity:** O(k \* (m + n)^2), **Space Complexity:** O(m + n)

	
	# Code
	```python
	def maxNumber(nums1, nums2, k):
    """
    Finds the maximum number of length k formed from digits of nums1 and nums2.

    Args:
        nums1: List of integers representing digits of the first number.
        nums2: List of integers representing digits of the second number.
        k: The desired length of the resulting number.

    Returns:
        A list of integers representing the maximum number.
    """

    def max_subsequence(nums, length):
        """
        Finds the maximum subsequence of length 'length' from 'nums'.
        """
        stack = []
        drop = len(nums) - length
        for num in nums:
            while stack and drop > 0 and stack[-1] < num:
                stack.pop()
                drop -= 1
            stack.append(num)
        return stack[:length]

    def merge(nums1, nums2):
        """
        Merges two subsequences to create a larger sequence.
        """
        result = []
        i, j = 0, 0
        while i < len(nums1) or j < len(nums2):
            if nums1[i:] > nums2[j:]:
                result.append(nums1[i])
                i += 1
            else:
                result.append(nums2[j])
                j += 1
        return result

    max_num = []
    for i in range(max(0, k - len(nums2)), min(k, len(nums1)) + 1):
        seq1 = max_subsequence(nums1, i)
        seq2 = max_subsequence(nums2, k - i)
        merged_seq = merge(seq1, seq2)
        if not max_num or merged_seq > max_num:
            max_num = merged_seq

    return max_num
	```