# Solving Leetcode Interviews in Seconds with AI: Find the Minimum Possible Sum of a Beautiful Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2834" 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 positive integers n and target. An array nums is beautiful if it meets the following conditions:  nums.length == n. nums consists of pairwise distinct positive integers. There doesn't exist two distinct indices, i and j, in the range [0, n - 1], such that nums[i] + nums[j] == target.  Return the minimum possible sum that a beautiful array could have modulo 109 + 7.   Example 1:  Input: n = 2, target = 3 Output: 4 Explanation: We can see that nums = [1,3] is beautiful. - The array nums has length n = 2. - The array nums consists of pairwise distinct positive integers. - There doesn't exist two distinct indices, i and j, with nums[i] + nums[j] == 3. It can be proven that 4 is the minimum possible sum that a beautiful array could have.  Example 2:  Input: n = 3, target = 3 Output: 8 Explanation: We can see that nums = [1,3,4] is beautiful. - The array nums has length n = 3. - The array nums consists of pairwise distinct positive integers. - There doesn't exist two distinct indices, i and j, with nums[i] + nums[j] == 3. It can be proven that 8 is the minimum possible sum that a beautiful array could have.  Example 3:  Input: n = 1, target = 1 Output: 1 Explanation: We can see, that nums = [1] is beautiful.    Constraints:  1 <= n <= 109 1 <= target <= 109  

	# Explanation
	Here's the solution:

*   **Key Idea:** To minimize the sum, we should include the smallest possible numbers. We include numbers less than `target/2` only if their complement (target - num) is not already included. To minimize the sum, preferentially exclude numbers less than `target/2`. We include all numbers greater than or equal to `target/2` up to `n` numbers in total.
*   **Efficient Calculation:** Instead of iterating, we can directly calculate the sum of arithmetic series for numbers less than `target/2` that need to be skipped and then calculate the sum of the remaining numbers.
*   **Modulo Arithmetic:** Perform all calculations modulo 10<sup>9</sup> + 7 to prevent overflow.

*   **Complexity:**
    *   Runtime Complexity: O(1)
    *   Storage Complexity: O(1)

	
	# Code
	```python
	def solve():
    n = int(input())
    target = int(input())
    MOD = 10**9 + 7

    count_less_than_half = target // 2
    
    if n <= count_less_than_half:
        start = target
        end = target + n - 1
        ans = (n * (start + end) // 2) % MOD
    else:
        sum_less_than_half = (count_less_than_half * (count_less_than_half + 1) // 2) % MOD
        
        remaining = n - count_less_than_half
        
        start = target
        end = target + remaining - 1
        
        sum_greater_than_half = (remaining * (start + end) // 2) % MOD
        
        ans = (sum_less_than_half + sum_greater_than_half) % MOD
        
    print(ans)

solve()
	```