# Solving Leetcode Interviews in Seconds with AI: Maximum and Minimum Sums of at Most Size K Subsequences


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3428" 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 nums and a positive integer k. Return the sum of the maximum and minimum elements of all subsequences of nums with at most k elements. Since the answer may be very large, return it modulo 109 + 7.   Example 1:  Input: nums = [1,2,3], k = 2 Output: 24 Explanation: The subsequences of nums with at most 2 elements are:    Subsequence  Minimum Maximum Sum   [1] 1 1 2   [2] 2 2 4   [3] 3 3 6   [1, 2] 1 2 3   [1, 3] 1 3 4   [2, 3] 2 3 5   Final Total     24    The output would be 24.  Example 2:  Input: nums = [5,0,6], k = 1 Output: 22 Explanation:  For subsequences with exactly 1 element, the minimum and maximum values are the element itself. Therefore, the total is 5 + 5 + 0 + 0 + 6 + 6 = 22.  Example 3:  Input: nums = [1,1,1], k = 2 Output: 12 Explanation: The subsequences [1, 1] and [1] each appear 3 times. For all of them, the minimum and maximum are both 1. Thus, the total is 12.    Constraints:  1 <= nums.length <= 105 0 <= nums[i] <= 109 1 <= k <= min(70, nums.length)  

	# Explanation
	Here's a breakdown of the solution and the Python code:

*   **High-Level Approach:**
    *   Sort the input array `nums`. This enables us to efficiently find minimums and maximums.
    *   Iterate through the sorted array. For each element, determine how many times it will be the minimum and maximum element in a subsequence of at most `k` elements. Use combinations (nCr) to calculate the number of such subsequences.
    *   Calculate the contribution of each element to the total sum as both the minimum and maximum, considering the modulo.

*   **Complexity:**
    *   Runtime: O(n log n) due to sorting, and O(n*k) due to the generation of the combinations table. Thus, we can say O(n log n + nk).
    *   Storage: O(k) primarily for storing combinations and intermediate results.

```python
def solve():
    def subsequenceSum(nums, k):
        n = len(nums)
        nums.sort()
        MOD = 10**9 + 7

        # Precompute combinations (nCr) using dynamic programming
        C = [[0] * (k + 1) for _ in range(n + 1)]
        for i in range(n + 1):
            C[i][0] = 1
            for j in range(1, min(i, k) + 1):
                C[i][j] = (C[i-1][j-1] + C[i-1][j]) % MOD

        total_sum = 0
        for i in range(n):
            # Count subsequences where nums[i] is the minimum
            for length in range(1, k + 1):
                if length > 1:
                    if i > 0 and length -1 <= i:
                        total_sum = (total_sum + nums[i] * C[i][length - 1]) % MOD
                else:
                    total_sum = (total_sum + nums[i]) % MOD

            # Count subsequences where nums[i] is the maximum
            for length in range(1, k+1):
                if length > 1:
                    if n - 1 - i > 0 and length - 1 <= n - 1 - i:
                        total_sum = (total_sum + nums[i] * C[n - 1 - i][length - 1]) % MOD
                else:
                    total_sum = (total_sum + nums[i]) % MOD

        return total_sum % MOD
    
    nums = [int(x) for x in input().split()]
    k = int(input())
    print(subsequenceSum(nums, k))

	
	# Code
	```python
	def solve():    def subsequenceSum(nums, k):
        n = len(nums)
        nums.sort()
        MOD = 10**9 + 7

        # Precompute combinations (nCr) using dynamic programming
        C = [[0] * (k + 1) for _ in range(n + 1)]
        for i in range(n + 1):
            C[i][0] = 1
            for j in range(1, min(i, k) + 1):
                C[i][j] = (C[i-1][j-1] + C[i-1][j]) % MOD

        total_sum = 0
        for i in range(n):
            # Count subsequences where nums[i] is the minimum
            for length in range(1, k + 1):
                if length > 1:
                    if i > 0 and length -1 <= i:
                        total_sum = (total_sum + nums[i] * C[i][length - 1]) % MOD
                else:
                    total_sum = (total_sum + nums[i]) % MOD

            # Count subsequences where nums[i] is the maximum
            for length in range(1, k+1):
                if length > 1:
                    if n - 1 - i > 0 and length - 1 <= n - 1 - i:
                        total_sum = (total_sum + nums[i] * C[n - 1 - i][length - 1]) % MOD
                else:
                    total_sum = (total_sum + nums[i]) % MOD

        return total_sum % MOD
    
    nums = [int(x) for x in input().split()]
    k = int(input())
    print(subsequenceSum(nums, k))
	```