Maximum Ascending Subarray Sum - Practice Coding Problems

Maximum Ascending Subarray Sum - Problem

Array Easy

Imagine you're analyzing stock prices throughout a day, looking for the longest streak of consecutive price increases that gives you the maximum profit potential. This is exactly what we're solving here!

Given an array of positive integers nums, your task is to find the maximum possible sum of a strictly ascending (increasing) subarray.

Key Points:

A subarray is a contiguous sequence of elements
Strictly ascending means each element must be larger than the previous one
We want the sum of such a subarray that gives us the maximum value

Example: In [10,20,30,5,10,50], the ascending subarrays are [10,20,30] (sum=60), [5,10,50] (sum=65), and single elements. The answer is 65.

Input & Output

example_1.py — Basic Ascending Sequence

$ Input: [10,20,30,5,10,50]

› Output: 65

💡 Note: We have two ascending subsequences: [10,20,30] with sum 60, and [5,10,50] with sum 65. The maximum is 65.

example_2.py — Multiple Single Elements

$ Input: [10,20,30,40,50]

› Output: 150

💡 Note: The entire array is strictly ascending, so we sum all elements: 10+20+30+40+50 = 150.

example_3.py — Decreasing Array

$ Input: [12,17,15,13,10,11,12]

› Output: 33

💡 Note: The longest ascending subsequence is [10,11,12] at the end with sum 33. Other sequences like [12,17] have smaller sums.

Visualization

Tap to expand

Understanding the Visualization

Track Current Rally

Keep running total of current consecutive price increases

Detect Rally End

When price drops or stays same, current rally ends

Start New Rally

Begin tracking new rally from current price point

Remember Best Rally

Always keep track of the most profitable rally seen so far

Key Takeaway

🎯 Key Insight: Like finding the best stock rally, we only need one pass through the data. When the trend breaks, we immediately start fresh while remembering our best performance so far.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using two variables to track current and maximum sums

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
All integers are positive

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

The optimal solution uses a one-pass sliding window technique with O(n) time and O(1) space complexity. We track the current ascending sequence sum and update the maximum whenever we find a larger sum. When the sequence breaks (current ≤ previous), we start fresh with the current element.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Optimal (Sliding Window)	O(n)	O(1)	Scan through array once, tracking current ascending sequence sum
Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray to see if it's ascending and track the maximum sum

One-Pass Optimal (Sliding Window) — Algorithm Steps

Initialize max_sum and current_sum to the first element
Iterate through the array starting from the second element
If current element > previous element, add it to current_sum
Otherwise, start a new sequence with current_sum = current element
Update max_sum whenever current_sum is larger
Return max_sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with first element as both current and maximum sum

Scan Forward

For each element, check if it continues the ascending pattern

Extend or Reset

If ascending, add to current sum; otherwise start fresh

Track Maximum

Always update maximum sum when current sum exceeds it

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int maxAscendingSum(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    int maxSum = nums[0];
    int currentSum = nums[0];
    
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] > nums[i - 1]) {
            // Continue current ascending sequence
            currentSum += nums[i];
        } else {
            // Start new ascending sequence
            currentSum = nums[i];
        }
        
        // Update maximum sum found so far
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
    }
    
    return maxSum;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int size = 0;
    
    // Parse input
    char* token = strtok(line, "[],\n ");
    while (token != NULL) {
        nums[size++] = atoi(token);
        token = strtok(NULL, "[],\n ");
    }
    
    printf("%d\n", maxAscendingSum(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using two variables to track current and maximum sums

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
All integers are positive

31.2K Views

Medium Frequency

~15 min Avg. Time

1.3K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Optimal (Sliding Window) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler