##### Welcome to Subscribe On Youtube

Formatted question description: https://leetcode.ca/all/1800.html

# 1800. Maximum Ascending Subarray Sum

Easy

## Description

Given an array of positive integers nums, return the maximum possible sum of an ascending subarray in nums.

A subarray is defined as a contiguous sequence of numbers in an array.

A subarray [nums_l, nums_(l+1), ..., nums_(r-1), nums_r] is ascending if for all i where l <= i < r, nums_i < nums_(i+1). Note that a subarray of size 1 is ascending.

Example 1:

Input: nums = [10,20,30,5,10,50]

Output: 65

Explanation: [5,10,50] is the ascending subarray with the maximum sum of 65.

Example 2:

Input: nums = [10,20,30,40,50]

Output: 150

Explanation: [10,20,30,40,50] is the ascending subarray with the maximum sum of 150.

Example 3:

Input: nums = [12,17,15,13,10,11,12]

Output: 33

Explanation: [10,11,12] is the ascending subarray with the maximum sum of 33.

Example 4:

Input: nums = [100,10,1]

Output: 100

Constraints:

• 1 <= nums.length <= 100
• 1 <= nums[i] <= 100

## Solution

Initialize the maximum sum and the sum as nums[0]. Loop over nums. For each element, if the current element is greater than the previous element, then add the current element to the sum. Otherwise, update the sum as the current element. Maintain the maximum sum and return the maximum sum.

• class Solution {
public int maxAscendingSum(int[] nums) {
int maxSum = nums[0], sum = nums[0];
int length = nums.length;
for (int i = 1; i < length; i++) {
if (nums[i] > nums[i - 1])
sum += nums[i];
else
sum = nums[i];
maxSum = Math.max(maxSum, sum);
}
return maxSum;
}
}

############

class Solution {
public int maxAscendingSum(int[] nums) {
int ans = 0, t = 0;
for (int i = 0; i < nums.length; ++i) {
if (i == 0 || nums[i] > nums[i - 1]) {
t += nums[i];
ans = Math.max(ans, t);
} else {
t = nums[i];
}
}
return ans;
}
}

• // OJ: https://leetcode.com/problems/maximum-ascending-subarray-sum/
// Time: O(N)
// Space: O(1)
class Solution {
public:
int maxAscendingSum(vector<int>& A) {
int ans = A[0], sum = A[0];
for (int i = 1; i < A.size(); ++i) {
if (A[i] > A[i - 1]) {
sum += A[i];
} else {
sum = A[i];
}
ans = max(ans, sum);
}
return ans;
}
};

• class Solution:
def maxAscendingSum(self, nums: List[int]) -> int:
ans = t = 0
for i, v in enumerate(nums):
if i == 0 or v > nums[i - 1]:
t += v
ans = max(ans, t)
else:
t = v
return ans

############

# 1800. Maximum Ascending Subarray Sum
# https://leetcode.com/problems/maximum-ascending-subarray-sum/

class Solution:
def maxAscendingSum(self, nums: List[int]) -> int:
res = total = nums[0]
n = len(nums)

for i in range(1, n):
if nums[i] > nums[i-1]:
total += nums[i]
else:
total = nums[i]

res = max(res, total)

return res


• func maxAscendingSum(nums []int) int {
ans, t := 0, 0
for i, v := range nums {
if i == 0 || v > nums[i-1] {
t += v
if ans < t {
ans = t
}
} else {
t = v
}
}
return ans
}

• function maxAscendingSum(nums: number[]): number {
const n = nums.length;
let res = nums[0];
let sum = nums[0];
for (let i = 1; i < n; i++) {
if (nums[i] <= nums[i - 1]) {
res = Math.max(res, sum);
sum = 0;
}
sum += nums[i];
}
return Math.max(res, sum);
}


• impl Solution {
pub fn max_ascending_sum(nums: Vec<i32>) -> i32 {
let n = nums.len();
let mut res = nums[0];
let mut sum = nums[0];
for i in 1..n {
if nums[i - 1] >= nums[i] {
res = res.max(sum);
sum = 0;
}
sum += nums[i];
}
res.max(sum)
}
}