Maximum Ascending Subarray Sum

Maximum Ascending Subarray Sum - Problem

Array Easy

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

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

An ascending subarray is one where each element is strictly greater than the previous element: nums[i] < nums[i+1] < nums[i+2] ...

Input & Output

Example 1 — Basic Ascending Sequence

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

› Output: 65

💡 Note: Two ascending subarrays: [10,20,30] with sum 60 and [5,10,50] with sum 65. Maximum is 65.

Example 2 — Single Elements

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

› Output: 100

💡 Note: Entire array is ascending: 10 < 20 < 30 < 40, sum = 10+20+30+40 = 100.

Example 3 — Decreasing Array

$ Input: nums = [5,4,3,2,1]

› Output: 5

💡 Note: No ascending subarray exists except single elements. Maximum single element is 5.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 8

The key insight is to track the current ascending subarray sum and reset when the sequence breaks. The optimal approach uses a single pass through the array, maintaining current and maximum sums. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(1)

Generate all possible subarrays, check if each is strictly ascending, and track the maximum sum found. This exhaustively examines every contiguous subsequence.

Single Pass - Track Current Ascending Sum

⏱️ Time: O(n) Space: O(1)

Iterate through the array once, maintaining a running sum of the current ascending subarray. When we encounter a non-ascending element, reset the current sum and start a new sequence.

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: Generate all possible subarrays using nested loops
Step 2: For each subarray, check if it's strictly ascending
Step 3: If ascending, calculate sum and update maximum

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Create all possible contiguous subarrays

Check Ascending

Verify each subarray is strictly increasing

Track Maximum

Keep the highest sum found

Code -

solution.c — C

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

int solution(int* nums, int n) {
    int maxSum = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if subarray nums[i:j+1] is strictly ascending
            int isAscending = 1;
            int currentSum = nums[i];
            
            for (int k = i + 1; k <= j; k++) {
                if (nums[k] <= nums[k - 1]) {
                    isAscending = 0;
                    break;
                }
                currentSum += nums[k];
            }
            
            // Update maxSum if this subarray is ascending
            if (isAscending) {
                if (currentSum > maxSum) {
                    maxSum = currentSum;
                }
            }
        }
    }
    
    return maxSum;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing - count commas to get array size
    int count = 1;
    for (int i = 0; line[i]; i++) {
        if (line[i] == ',') count++;
    }
    
    int* nums = malloc(count * sizeof(int));
    char* token = strtok(line + 1, ",]");
    int i = 0;
    while (token && i < count) {
        nums[i] = atoi(token);
        token = strtok(NULL, ",]");
        i++;
    }
    
    int result = solution(nums, count);
    printf("%d\n", result);
    
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n²) subarrays × O(n) to check each

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables for tracking, no extra data structures

✓ Linear Space

24.1K Views

Medium Frequency

~8 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler