1class Solution {
2    public int getSum(int[] nums) {
3        final int MOD = (int) 1e9 + 7; // Define the modulus for large integer handling.
4        long sumConsecutiveIncreasing = nums[0]; // Sum for consecutive increasing sequence.
5        long sumConsecutiveDecreasing = nums[0]; // Sum for consecutive decreasing sequence.
6        long result = nums[0]; // Result initialized with the first element.
7        int incrCount = 1; // Counter for increasing sequences.
8        int decrCount = 1; // Counter for decreasing sequences.
9
10        for (int i = 1; i < nums.length; ++i) {
11            int prev = nums[i - 1]; // Previous element in the array.
12            int curr = nums[i]; // Current element in the array.
13
14            // If the sequence is increasing consecutively.
15            if (curr - prev == 1) {
16                ++incrCount; // Increment the counter for increasing sequences.
17                sumConsecutiveIncreasing += 1L * incrCount * curr; // Update the sum with the current element.
18                result = (result + sumConsecutiveIncreasing) % MOD; // Update result ensuring it's within MOD.
19            } else {
20                incrCount = 1; // Reset the increasing counter.
21                sumConsecutiveIncreasing = curr; // Set sum to the current element.
22            }
23          
24            // If the sequence is decreasing consecutively.
25            if (curr - prev == -1) {
26                ++decrCount; // Increment the counter for decreasing sequences.
27                sumConsecutiveDecreasing += 1L * decrCount * curr; // Update the sum with the current element.
28                result = (result + sumConsecutiveDecreasing) % MOD; // Update result ensuring it's within MOD.
29            } else {
30                decrCount = 1; // Reset the decreasing counter.
31                sumConsecutiveDecreasing = curr; // Set sum to the current element.
32            }
33
34            // If the current and previous elements are not consecutive in either direction.
35            if (Math.abs(curr - prev) != 1) {
36                result = (result + curr) % MOD; // Add the current element to the result enforcing the MOD.
37            }
38        }
39
40        return (int) result; // Convert result back to an integer and return.
41    }
42}
43

1class Solution {
2public:
3    int getSum(vector<int>& nums) {
4        const int mod = 1e9 + 7;  // Modulo value for preventing overflow
5        long long increasingSum = nums[0];
6        long long decreasingSum = nums[0];
7        long long totalSum = nums[0];
8        int increasingCount = 1;
9        int decreasingCount = 1;
10
11        for (int i = 1; i < nums.size(); ++i) {
12            int previousNum = nums[i - 1];
13            int currentNum = nums[i];
14
15            // Handle increasing sequences
16            if (currentNum - previousNum == 1) {
17                // If current number continues increasing sequence
18                ++increasingCount;
19                increasingSum += 1LL * increasingCount * currentNum;
20                totalSum = (totalSum + increasingSum) % mod;
21            } else {
22                // Reset for new increasing sequence
23                increasingCount = 1;
24                increasingSum = currentNum;
25            }
26
27            // Handle decreasing sequences
28            if (currentNum - previousNum == -1) {
29                // If current number continues decreasing sequence
30                ++decreasingCount;
31                decreasingSum += 1LL * decreasingCount * currentNum;
32                totalSum = (totalSum + decreasingSum) % mod;
33            } else {
34                // Reset for new decreasing sequence
35                decreasingCount = 1;
36                decreasingSum = currentNum;
37            }
38
39            // Account for numbers not part of increasing or decreasing sequence
40            if (abs(currentNum - previousNum) != 1) {
41                totalSum = (totalSum + currentNum) % mod;
42            }
43        }
44        return totalSum;
45    }
46};
47

1// Function to calculate a modified cumulative sum based on consecutive sequences in an array
2function getSum(nums: number[]): number {
3    const mod = 10 ** 9 + 7; // Constant value for modulo operation to prevent overflow
4    let increasingCount = 1, decreasingCount = 1; // Track lengths of increasing and decreasing sequences
5    let increasingSum = nums[0], decreasingSum = nums[0]; // Sum of increasing and decreasing sequences
6    let result = nums[0]; // Resultant sum initialized with the first element
7
8    // Iterate through the array starting from the second element
9    for (let i = 1; i < nums.length; i++) {
10        const previous = nums[i - 1];
11        const current = nums[i];
12
13        // Check if current element continues an increasing sequence
14        if (current - previous === 1) {
15            increasingCount++;
16            increasingSum += increasingCount * current;
17            result = (result + increasingSum) % mod;
18        } else {
19            increasingCount = 1;
20            increasingSum = current;
21        }
22
23        // Check if current element continues a decreasing sequence
24        if (current - previous === -1) {
25            decreasingCount++;
26            decreasingSum += decreasingCount * current;
27            result = (result + decreasingSum) % mod;
28        } else {
29            decreasingCount = 1;
30            decreasingSum = current;
31        }
32
33        // Add current element to result if it doesn't belong to an increasing or decreasing sequence
34        if (Math.abs(current - previous) !== 1) {
35            result = (result + current) % mod;
36        }
37    }
38
39    return result; // Return the calculated result
40}
41