# Solving Leetcode Interviews in Seconds with AI: Form Largest Integer With Digits That Add up to Target


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1449" 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
	> Given an array of integers cost and an integer target, return the maximum integer you can paint under the following rules:  The cost of painting a digit (i + 1) is given by cost[i] (0-indexed). The total cost used must be equal to target. The integer does not have 0 digits.  Since the answer may be very large, return it as a string. If there is no way to paint any integer given the condition, return "0".   Example 1:  Input: cost = [4,3,2,5,6,7,2,5,5], target = 9 Output: "7772" Explanation: The cost to paint the digit '7' is 2, and the digit '2' is 3. Then cost("7772") = 2*3+ 3*1 = 9. You could also paint "977", but "7772" is the largest number. Digit    cost   1  ->   4   2  ->   3   3  ->   2   4  ->   5   5  ->   6   6  ->   7   7  ->   2   8  ->   5   9  ->   5  Example 2:  Input: cost = [7,6,5,5,5,6,8,7,8], target = 12 Output: "85" Explanation: The cost to paint the digit '8' is 7, and the digit '5' is 5. Then cost("85") = 7 + 5 = 12.  Example 3:  Input: cost = [2,4,6,2,4,6,4,4,4], target = 5 Output: "0" Explanation: It is impossible to paint any integer with total cost equal to target.    Constraints:  cost.length == 9 1 <= cost[i], target <= 5000  

	# Explanation
	Here's the breakdown of the solution:

*   **Dynamic Programming:** We'll use dynamic programming to find the longest possible string for each cost from 0 to `target`. The DP table will store strings, and we'll aim to maximize the length of the string at each DP state while prioritizing larger digits.
*   **Iteration and Optimization:** Iterate through the cost array (representing digits 1-9). For each digit, update the DP table by checking if adding that digit improves the string for a given cost.  If the new string formed by adding the digit is longer, or has the same length but is lexicographically larger, we'll update the DP table.
*   **Backtracking (Implicit):** The string itself acts as a record of decisions made during the DP process, implicitly storing the path that leads to the optimal solution for each cost value.

*   **Runtime Complexity: O(9 * target), Storage Complexity: O(target)**

	
	# Code
	```python
	def largestNumber(cost, target):
    """
    Finds the largest number that can be painted with the given cost and target.

    Args:
        cost: A list of integers representing the cost of each digit (1-9).
        target: The total cost to achieve.

    Returns:
        The largest number as a string, or "0" if no solution exists.
    """

    dp = [""] * (target + 1)

    for t in range(1, target + 1):
        for digit in range(9):
            c = cost[digit]
            d = str(digit + 1)

            if c <= t:
                if c == t:
                    if len(d) > len(dp[t]) or (len(d) == len(dp[t]) and d > dp[t]):
                        dp[t] = d
                else:
                    prev = dp[t - c]
                    if prev != "":
                        new_str = prev + d
                        if len(new_str) > len(dp[t]) or (len(new_str) == len(dp[t]) and new_str > dp[t]):
                            dp[t] = new_str

    return dp[target] if dp[target] != "" else "0"
	```