# Solving Leetcode Interviews in Seconds with AI: Sum of Good Subsequences


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3351" 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. A good subsequence is defined as a subsequence of nums where the absolute difference between any two consecutive elements in the subsequence is exactly 1. Return the sum of all possible good subsequences of nums. Since the answer may be very large, return it modulo 109 + 7. Note that a subsequence of size 1 is considered good by definition.   Example 1:  Input: nums = [1,2,1] Output: 14 Explanation:  Good subsequences are: [1], [2], [1], [1,2], [2,1], [1,2,1]. The sum of elements in these subsequences is 14.   Example 2:  Input: nums = [3,4,5] Output: 40 Explanation:  Good subsequences are: [3], [4], [5], [3,4], [4,5], [3,4,5]. The sum of elements in these subsequences is 40.     Constraints:  1 <= nums.length <= 105 0 <= nums[i] <= 105  

	# Explanation
	Here's a breakdown of the approach, complexities, and the Python code:

*   **Dynamic Programming:** The solution utilizes dynamic programming to efficiently calculate the sum of good subsequences. A dictionary `dp` stores the sum of good subsequences ending with a particular number.
*   **Iterative Calculation:** For each number in the input array, the code checks if `num - 1` exists in `dp`. If it does, it means we can extend existing good subsequences ending with `num - 1` by appending the current number. We update `dp[num]` accordingly.
*   **Modulo Arithmetic:** To prevent overflow, the code performs all calculations modulo 10<sup>9</sup> + 7.

*   **Runtime Complexity:** O(n), where n is the length of the input array.
*   **Storage Complexity:** O(k), where k is the number of distinct elements in the input array. In the worst case, k could be equal to n.

	
	# Code
	```python
	def sum_good_subsequences(nums: list[int]) -> int:
    """
    Calculates the sum of all possible good subsequences of nums.
    A good subsequence is defined as a subsequence where the absolute difference
    between any two consecutive elements is exactly 1.

    Args:
        nums: An integer array.

    Returns:
        The sum of all possible good subsequences of nums modulo 10^9 + 7.
    """
    dp = {}
    MOD = 10**9 + 7
    total_sum = 0

    for num in nums:
        current_val = num
        if num in dp:
            current_val = (current_val + dp[num]) % MOD #to take into account the contribution of all previous subsequences ending with num

        if num - 1 in dp:
            current_val = (current_val + dp[num - 1]) % MOD

        dp[num] = current_val
        total_sum = (total_sum + num) % MOD

        if num - 1 in dp:
             total_sum = (total_sum + dp[num-1]) % MOD

    dp2 = {}
    total_sum = 0

    for num in nums:
        val = num
        if num-1 in dp2:
            val = (val + dp2[num-1]) % MOD
        total_sum = (total_sum + val) % MOD
        dp2[num] = val
        
    return total_sum % MOD
	```