Maximum Subarray Sum With Length Divisible by K

Maximum Subarray Sum With Length Divisible by K - Problem

Given an array of integers nums and a positive integer k, find the maximum sum of any contiguous subarray whose length is divisible by k.

A subarray is a contiguous sequence of elements within an array. The length of a subarray must be a multiple of k (i.e., k, 2k, 3k, etc.) to be considered valid.

Example: If nums = [1, -3, 2, 1, -1] and k = 2, valid subarrays have lengths 2 or 4. The subarray [2, 1] has length 2 and sum 3, which would be the maximum.

Return the maximum sum among all valid subarrays, or 0 if no valid subarray exists.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, -3, 2, 1, -1], k = 2

› Output: 3

💡 Note: Valid subarrays with length divisible by 2: [1,-3] (sum=-2), [-3,2] (sum=-1), [2,1] (sum=3), [1,-1] (sum=0), [1,-3,2,1] (sum=1), [-3,2,1,-1] (sum=-1). Maximum sum is 3 from subarray [2,1].

example_2.py — All Negative

$ Input: nums = [-1, -2, -3], k = 2

› Output: -3

💡 Note: Valid subarrays with length divisible by 2: [-1,-2] (sum=-3), [-2,-3] (sum=-5). Maximum sum is -3.

example_3.py — Single Valid Subarray

$ Input: nums = [5, -2, 3], k = 3

› Output: 6

💡 Note: Only one valid subarray with length divisible by 3: [5,-2,3] with length 3 and sum 6.

Constraints

1 ≤ nums.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
1 ≤ k ≤ nums.length
At least one valid subarray must exist if nums.length ≥ k

Visualization

Tap to expand

Understanding the Visualization

Track Daily Revenue

Calculate cumulative revenue up to each day (prefix sums)

Group by Stay Pattern

Group positions by their remainder when divided by k (same booking pattern)

Find Best Periods

For each booking pattern, find the period with maximum revenue

Return Maximum

Choose the booking period with the highest total revenue

Key Takeaway

🎯 Key Insight: By tracking prefix sums and grouping positions by their remainder when divided by k, we can efficiently find all subarrays with lengths divisible by k and identify the one with maximum sum in linear time.

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses prefix sums with modular arithmetic. Key insight: a subarray has length divisible by k when start and end positions have the same remainder when divided by k. We track the minimum prefix sum for each remainder to maximize subarray sums in O(n) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Valid Subarrays)	O(n²)	O(1)	Check every possible subarray with length divisible by k
Prefix Sum with Modular Arithmetic (Optimal)	O(n)	O(k)	Use prefix sums and hash map to find maximum subarray in one pass

Brute Force (Check All Valid Subarrays) — Algorithm Steps

Initialize maxSum to negative infinity
For each starting position i from 0 to n-1
For each valid length (k, 2k, 3k, ...) that fits from position i
Calculate sum of subarray from i to i+length-1
Update maxSum if current sum is larger
Return maxSum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Check subarrays of length k, 2k, 3k starting from index 0

Move to position 1

Check subarrays of length k, 2k, 3k starting from index 1

Continue for all positions

Repeat until we've checked all possible starting positions

Track maximum

Keep track of the maximum sum found across all valid subarrays

Code -

solution.c — C

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

int maxSubArraySum(int* nums, int n, int k) {
    if (n < k) return 0;
    
    int maxSum = INT_MIN;
    int found = 0;
    
    // Try all starting positions
    for (int i = 0; i < n; i++) {
        int currentSum = 0;
        // Try all valid lengths from this starting position
        for (int j = i; j < n; j++) {
            currentSum += nums[j];
            int length = j - i + 1;
            // If length is divisible by k, consider this subarray
            if (length % k == 0) {
                if (currentSum > maxSum) {
                    maxSum = currentSum;
                }
                found = 1;
            }
        }
    }
    
    return found ? maxSum : 0;
}

int main() {
    int nums[1000];
    int n = 0;
    int k;
    
    // Read array
    char c;
    while (scanf("%d%c", &nums[n], &c) == 2) {
        n++;
        if (c == '\n') break;
    }
    
    scanf("%d", &k);
    printf("%d\n", maxSubArraySum(nums, n, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop runs n times, inner loop runs up to n/k times, and sum calculation takes O(k) on average

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum sums

✓ Linear Space

58.2K Views

Medium Frequency

~25 min Avg. Time

1.5K 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 Valid Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler