# Solving Leetcode Interviews in Seconds with AI: Maximum Number of Consecutive Values You Can Make


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1798" 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 an integer array coins of length n which represents the n coins that you own. The value of the ith coin is coins[i]. You can make some value x if you can choose some of your n coins such that their values sum up to x. Return the maximum number of consecutive integer values that you can make with your coins starting from and including 0. Note that you may have multiple coins of the same value.   Example 1:  Input: coins = [1,3] Output: 2 Explanation: You can make the following values: - 0: take [] - 1: take [1] You can make 2 consecutive integer values starting from 0. Example 2:  Input: coins = [1,1,1,4] Output: 8 Explanation: You can make the following values: - 0: take [] - 1: take [1] - 2: take [1,1] - 3: take [1,1,1] - 4: take [4] - 5: take [4,1] - 6: take [4,1,1] - 7: take [4,1,1,1] You can make 8 consecutive integer values starting from 0. Example 3:  Input: coins = [1,4,10,3,1] Output: 20   Constraints:  coins.length == n 1 <= n <= 4 * 104 1 <= coins[i] <= 4 * 104  

	# Explanation
	Here's the solution to the problem:

*   **Greedy Approach:** Sort the coins in ascending order. Iterate through the sorted coins, keeping track of the maximum reachable value so far.
*   **Reachable Value Extension:** If the current coin's value is less than or equal to the maximum reachable value + 1, then we can extend the reachable range by adding the current coin's value to the maximum reachable value.
*   **Consecutive Count:** The maximum reachable value + 1 represents the number of consecutive integer values we can make starting from 0.

*   **Runtime Complexity: O(n log n), Storage Complexity: O(1)**  (dominated by sorting, in-place sort if possible).

	
	# Code
	```python
	def getMaximumConsecutive(coins):
    coins.sort()
    reachable = 0
    for coin in coins:
        if coin <= reachable + 1:
            reachable += coin
        else:
            break
    return reachable + 1
	```