# Solving Leetcode Interviews in Seconds with AI: Number of Subsequences That Satisfy the Given Sum Condition


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1498" 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 array of integers nums and an integer target. Return the number of non-empty subsequences of nums such that the sum of the minimum and maximum element on it is less or equal to target. Since the answer may be too large, return it modulo 109 + 7.   Example 1:  Input: nums = [3,5,6,7], target = 9 Output: 4 Explanation: There are 4 subsequences that satisfy the condition. [3] -> Min value + max value <= target (3 + 3 <= 9) [3,5] -> (3 + 5 <= 9) [3,5,6] -> (3 + 6 <= 9) [3,6] -> (3 + 6 <= 9)  Example 2:  Input: nums = [3,3,6,8], target = 10 Output: 6 Explanation: There are 6 subsequences that satisfy the condition. (nums can have repeated numbers). [3] , [3] , [3,3], [3,6] , [3,6] , [3,3,6]  Example 3:  Input: nums = [2,3,3,4,6,7], target = 12 Output: 61 Explanation: There are 63 non-empty subsequences, two of them do not satisfy the condition ([6,7], [7]). Number of valid subsequences (63 - 2 = 61).    Constraints:  1 <= nums.length <= 105 1 <= nums[i] <= 106 1 <= target <= 106  

	# Explanation
	Here's a breakdown of the solution, followed by the Python code:

*   **Sorting and Two Pointers:** The core idea is to sort the input array `nums`. This allows us to efficiently find pairs of minimum and maximum elements that satisfy the given condition (min + max <= target) using a two-pointer approach.
*   **Counting Subsequences:** For each element `nums[i]` that can be a minimum in a valid subsequence, we find the largest index `j` such that `nums[i] + nums[j] <= target`. The number of subsequences with `nums[i]` as the minimum is then 2<sup>(j-i)</sup> (all possible combinations of elements between indices `i+1` and `j` can be added to the subsequence).
*   **Modulo Arithmetic:** The final result can be very large, so we perform the calculations modulo 10<sup>9</sup> + 7 to avoid overflow.

*   **Runtime Complexity:** O(N log N), where N is the length of the `nums` array due to sorting. **Storage Complexity:** O(N) in the worst case.

	
	# Code
	```python
	def countSubsequences(nums, target):
    nums.sort()
    n = len(nums)
    ans = 0
    mod = 10**9 + 7
    power = [1] * (n + 1)
    for i in range(1, n + 1):
        power[i] = (power[i - 1] * 2) % mod

    left = 0
    right = n - 1

    while left < n:
        while right >= 0 and nums[left] + nums[right] > target:
            right -= 1
        if left > right:
            break
        ans = (ans + power[right - left]) % mod
        left += 1

    return ans
	```