Kth Smallest Subarray Sum - Practice Coding Problems

Kth Smallest Subarray Sum - Problem

You're given an integer array nums of length n and an integer k. Your task is to find the kth smallest subarray sum among all possible subarrays.

A subarray is a contiguous sequence of elements within the array - for example, in array [1, 2, 3, 4], some subarrays are [1], [2, 3], [1, 2, 3, 4], etc. The subarray sum is simply the sum of all elements in that subarray.

Goal: Among all n(n+1)/2 possible subarray sums, return the kth smallest one (1-indexed).

Example: For nums = [2, 1, 3] and k = 4, the subarray sums are: [2] = 2, [1] = 1, [3] = 3, [2,1] = 3, [1,3] = 4, [2,1,3] = 6. Sorted: [1, 2, 3, 3, 4, 6]. The 4th smallest is 3.

Input & Output

example_1.py — Basic Case

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

› Output: 3

💡 Note: All subarrays: [2]=2, [2,1]=3, [2,1,3]=6, [1]=1, [1,3]=4, [3]=3. Sorted sums: [1,2,3,3,4,6]. The 4th smallest is 3.

example_2.py — Single Element

$ Input: nums = [5], k = 1

› Output: 5

💡 Note: Only one subarray [5] with sum 5, so the 1st smallest is 5.

example_3.py — All Equal Elements

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

› Output: 3

💡 Note: Subarrays: [3]=3, [3,3]=6, [3,3,3]=9, [3]=3, [3,3]=6, [3]=3. Sorted: [3,3,3,6,6,9]. The 2nd smallest is 3.

Constraints

1 ≤ nums.length ≤ 2000
1 ≤ nums[i] ≤ 5 × 10⁴
1 ≤ k ≤ nums.length × (nums.length + 1) / 2
All elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Set the range

Minimum pages = shortest book, Maximum pages = all books combined

Make a guess

Try the middle value: 'How many sessions have ≤ this many pages?'

Count efficiently

Use a sliding window approach to count sessions without listing them all

Adjust and repeat

If count < k, guess higher; if count ≥ k, guess lower until exact

Key Takeaway

🎯 Key Insight: Binary search on the answer space + efficient counting eliminates the need to generate and sort all subarray sums, reducing complexity from O(n² log n) to O(n log(sum)).

Asked in

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

The optimal approach uses binary search on the answer combined with a sliding window technique. Instead of generating all O(n²) subarray sums, we binary search on possible sum values and efficiently count how many subarrays have sum ≤ our target using a sliding window. This achieves O(n log(sum) log n) time complexity with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer (Optimal)	O(n log(sum) log n)	O(1)	Binary search on possible sum values and count subarrays efficiently
Brute Force (Generate All Sums)	O(n² log n)	O(n²)	Generate all possible subarray sums, sort them, and return the kth element

Binary Search on Answer (Optimal) — Algorithm Steps

Find the range of possible sums (min = smallest element, max = total sum)
Binary search on this range of possible sum values
For each mid value, count how many subarrays have sum ≤ mid
Use sliding window to count subarrays efficiently
Adjust search range based on count vs k until we find the exact answer

Visualization

Tap to expand

Step-by-Step Walkthrough

Set search bounds

left = min element, right = total sum

Binary search mid

Try mid = (left + right) / 2

Count subarrays ≤ mid

Use sliding window to count efficiently

Adjust bounds

If count < k, search higher; else search lower

Code -

solution.c — C

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

int countSubarraysWithSumLessEqual(int* nums, int n, int target) {
    int count = 0;
    int left = 0;
    int currentSum = 0;
    
    for (int right = 0; right < n; right++) {
        currentSum += nums[right];
        
        while (currentSum > target) {
            currentSum -= nums[left];
            left++;
        }
        
        count += right - left + 1;
    }
    
    return count;
}

int kthSmallestSubarraySum(int* nums, int n, int k) {
    int left = nums[0];
    int right = 0;
    
    // Find min and sum
    for (int i = 0; i < n; i++) {
        if (nums[i] < left) left = nums[i];
        right += nums[i];
    }
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (countSubarraysWithSumLessEqual(nums, n, mid) < k) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    return left;
}

int main() {
    int n, k;
    scanf("%d", &n);
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]);
    }
    scanf("%d", &k);
    printf("%d\n", kthSmallestSubarraySum(nums, n, k));
    free(nums);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(sum) log n)

Binary search on sum range (log(sum)) × counting subarrays for each mid (n log n)

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

38.5K Views

Medium-High Frequency

~25 min Avg. Time

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

Binary Search on Answer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler