Make K-Subarray Sums Equal - Practice Coding Problems

Make K-Subarray Sums Equal - Problem

Array Math Greedy Sorting Number Theory Medium

Circular Array Balancing Challenge

Imagine you have a circular integer array where elements are connected in a loop - the first element follows the last, and vice versa. Your mission is to make all consecutive subarrays of length k have the same sum using the minimum number of operations.

In each operation, you can increase or decrease any element by 1. The question is: what's the minimum total cost to achieve perfect balance?

Key Insight: Since the array is circular, elements at positions that differ by k must have the same value in the final state!

Example: If arr = [1,4,1,3] and k = 2, subarrays are [1,4], [4,1], [1,3], [3,1]. For all sums to be equal, we need 1+4 = 4+1 = 1+3 = 3+1, which means opposite elements must be equal.

Input & Output

example_1.py — Basic Case

$ Input: arr = [1,4,1,3], k = 2

› Output: 1

💡 Note: Subarrays are [1,4], [4,1], [1,3], [3,1] with sums 5,5,4,4. We can change arr[2] from 1 to 2, making all sums equal to 5. Total operations: 1.

example_2.py — All Equal

$ Input: arr = [2,5,5,7], k = 3

› Output: 5

💡 Note: Subarrays are [2,5,5], [5,5,7], [5,7,2], [7,2,5] with sums 12,17,14,14. Using GCD(4,3)=1, all positions form one cycle. Median is 5, so we need |2-5|+|5-5|+|5-5|+|7-5|=5 operations.

example_3.py — Edge Case k=1

$ Input: arr = [1,2,3,4], k = 1

› Output: 0

💡 Note: When k=1, each subarray has length 1, so each element forms its own sum. No operations needed since each sum is already 'equal' to itself.

Visualization

Tap to expand

Understanding the Visualization

Identify Constraint

All subarrays of length k must have equal sums

Find Cycles

Positions i and (i+k)%n must be equal in optimal solution

Apply Median Rule

For each cycle, median value minimizes total operations

Key Takeaway

🎯 Key Insight: In a circular array, positions that are k steps apart must have equal values for all k-subarrays to have equal sums. Use GCD to find cycles and median to minimize operations.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to group into cycles, O(n log n) for sorting values in cycles

⚡ Linearithmic

Space Complexity

O(n)

Space to store cycles and sorted values

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁹
1 ≤ k ≤ arr.length
Array is guaranteed to be circular

Asked in

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

The optimal solution uses GCD-based cycle detection. Key insight: positions that are k steps apart in the circular array must have equal values. We find GCD(n,k) cycles, and for each cycle, set all values to the median to minimize operations. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Insight with GCD	O(n log n)	O(n)	Use GCD to find cycles of positions that must be equal, then find median of each cycle
Brute Force (Try All Possible Sums)	O(n³)	O(1)	Try every possible target sum and calculate the minimum operations needed

Mathematical Insight with GCD — Algorithm Steps

Calculate GCD(n, k) to determine number of independent cycles
Group positions into cycles where positions k apart must be equal
For each cycle, collect all current values
Sort values in each cycle and find the median
Calculate operations needed to change all values to median

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate GCD

GCD(n,k) gives us the number of independent cycles

Group Cycles

Positions i, i+k, i+2k, ... form cycles

Find Medians

Median minimizes total operations for each cycle

Code -

solution.c — C

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

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

long long makeSubKSumEqual(int* arr, int arrSize, int k) {
    int n = arrSize;
    int g = gcd(n, k);
    long long totalOps = 0;
    
    for (int start = 0; start < g; start++) {
        int cycleValues[1000];
        int cycleSize = 0;
        int pos = start;
        
        do {
            cycleValues[cycleSize++] = arr[pos];
            pos = (pos + k) % n;
        } while (pos != start);
        
        qsort(cycleValues, cycleSize, sizeof(int), compare);
        int median = cycleValues[cycleSize / 2];
        
        for (int i = 0; i < cycleSize; i++) {
            totalOps += abs(cycleValues[i] - median);
        }
    }
    
    return totalOps;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n) to group into cycles, O(n log n) for sorting values in cycles

⚡ Linearithmic

Space Complexity

O(n)

Space to store cycles and sorted values

⚡ Linearithmic Space

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁹
1 ≤ k ≤ arr.length
Array is guaranteed to be circular

32.0K Views

Medium Frequency

~25 min Avg. Time

950 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

Mathematical Insight with GCD — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler