Maximum Subarray - Practice Coding Problems

Maximum Subarray - Problem

You are given an integer array nums. Your task is to find the contiguous subarray (containing at least one number) that has the largest sum and return that sum.

A subarray is a contiguous part of an array. For example, in the array [1, 2, 3], the subarrays are: [1], [2], [3], [1, 2], [2, 3], and [1, 2, 3].

Goal: Find the subarray with maximum sum efficiently.

Input: An integer array nums

Output: An integer representing the maximum sum of any contiguous subarray

Input & Output

example_1.py — Basic Case

$ Input: [-2,1,-3,4,-1,2,1,-5,4]

› Output: 6

💡 Note: The subarray [4,-1,2,1] has the largest sum of 6. This demonstrates how we can include negative numbers if they're surrounded by larger positive numbers.

example_2.py — Single Element

$ Input: [1]

› Output: 1

💡 Note: When there's only one element, it forms the maximum subarray by itself.

example_3.py — All Negative Numbers

$ Input: [-3,-2,-1,-4]

› Output: -1

💡 Note: When all numbers are negative, we choose the least negative number as our maximum subarray. Here -1 is the largest among all negative numbers.

Visualization

Tap to expand

Understanding the Visualization

Track Running Profit

Keep adding daily profits to your running total

Remember Best Period

Always remember the best consecutive period seen so far

Cut Losses

If your running total goes negative, start fresh from the next day

Optimal Strategy

This greedy approach guarantees finding the maximum profit period

Key Takeaway

🎯 Key Insight: If your current profit streak becomes negative, it's always better to start fresh rather than carry the loss forward. This greedy decision leads to the optimal solution!

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop runs n times, inner loop runs up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track sums and indices

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
The array contains at least one element

Asked in

G Google 65 a Amazon 58 f Meta 42 ⊞ Microsoft 38 Apple 25

The optimal solution uses Kadane's Algorithm, a dynamic programming approach that finds the maximum subarray sum in O(n) time and O(1) space. The key insight is to track the current sum and decide at each element whether to extend the existing subarray or start a new one.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray and find the maximum sum
Dynamic Programming (Kadane's Algorithm)	O(n)	O(1)	Optimal O(n) solution using Kadane's algorithm to track maximum sum

Brute Force (Check All Subarrays) — Algorithm Steps

Use outer loop to set the starting index of subarray
Use inner loop to set the ending index of subarray
Calculate sum of current subarray
Update maximum sum if current sum is larger
Return the maximum sum found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Check subarray starting at index 0

Extend subarray

Add next elements one by one and calculate sum

Move to next start

Start new subarray from index 1 and repeat

Track maximum

Keep track of the maximum sum found so far

Code -

solution.c — C

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

int maxSubArray(int* nums, int numsSize) {
    int maxSum = INT_MIN;
    
    for (int i = 0; i < numsSize; i++) {
        int currentSum = 0;
        for (int j = i; j < numsSize; j++) {
            currentSum += nums[j];
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
        }
    }
    
    return maxSum;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop runs n times, inner loop runs up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track sums and indices

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁴ ≤ nums[i] ≤ 10⁴
The array contains at least one element

94.2K Views

Very High Frequency

~15 min Avg. Time

2.8K 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

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler