Count Subarrays With Score Less Than K - Practice Coding Problems

Count Subarrays With Score Less Than K - Problem

Imagine you're analyzing performance metrics for different data segments. The score of an array is defined as the product of its sum and its length.

For example, the score of [1, 2, 3, 4, 5] is calculated as:
(1 + 2 + 3 + 4 + 5) × 5 = 15 × 5 = 75

Given a positive integer array nums and an integer k, your task is to count how many non-empty subarrays have a score that is strictly less than k.

A subarray is a contiguous sequence of elements within an array. This problem tests your ability to efficiently handle range queries and optimize nested computations.

Input & Output

example_1.py — Basic Case

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

› Output: 6

💡 Note: Valid subarrays with score < 10 are: [2] (score=2), [1] (score=1), [4] (score=4), [3] (score=3), [5] (score=5), and [2,1] (score=6). Total count = 6.

example_2.py — Larger threshold

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

› Output: 5

💡 Note: Valid subarrays: [1] (score=1), [1] (score=1), [1] (score=1), [1,1] (score=4), [1,1] (score=4). Note: [1,1,1] has score=9 which is ≥5.

example_3.py — Edge Case

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

› Output: 1

💡 Note: Only one subarray [1] with score = 1×1 = 1 < 2.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ 10¹⁵
All array elements are positive integers

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Start with both pointers at the beginning, representing day 1 of analysis

Expand Window

Add more days to the analysis period, updating running totals

Check Performance

Calculate score as (total revenue) × (number of days)

Shrink if Needed

If performance score exceeds threshold, remove days from the start

Count Valid Periods

For each ending day, count how many valid periods end there

Key Takeaway

🎯 Key Insight: The sliding window technique allows us to count all valid subarrays in O(n) time by maintaining a window that expands rightward and shrinks leftward when needed, avoiding the O(n³) brute force approach.

Asked in

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

The optimal solution uses a sliding window technique with two pointers. We maintain a window that expands rightward and shrinks leftward when the score becomes too large. For each valid right position, we count all subarrays ending at that position. This achieves O(n) time complexity compared to the brute force O(n³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible subarray by calculating sum and score directly
Sliding Window (Two Pointers)	O(n)	O(1)	Use expanding and shrinking window to efficiently count valid subarrays

Brute Force (Nested Loops) — Algorithm Steps

Use outer loop for starting position i
Use inner loop for ending position j
Calculate sum of elements from i to j
Calculate score as sum × length
Increment counter if score < k

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin checking subarrays starting from index 0

Extend subarray

For each starting position, try all possible ending positions

Calculate score

Sum all elements and multiply by length

Check condition

If score < k, increment counter

Code -

solution.c — C

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

int countSubarrays(int* nums, int numsSize, long long k) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Calculate sum of subarray from i to j
            long long subarraySum = 0;
            for (int x = i; x <= j; x++) {
                subarraySum += nums[x];
            }
            int length = j - i + 1;
            long long score = subarraySum * length;
            
            if (score < k) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[] = {2, 1, 4, 3, 5};
    long long k = 10;
    printf("%d\n", countSubarrays(nums, 5, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested operations: O(n²) for all subarrays and O(n) to calculate sum of each

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to store current sum and count

✓ Linear Space

52.3K Views

High Frequency

~25 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler