Subarray With Elements Greater Than Varying Threshold

Subarray With Elements Greater Than Varying Threshold - Problem

You're given an integer array nums and an integer threshold. Your mission is to find any subarray of length k where every single element is greater than threshold / k.

The twist? The threshold varies based on the subarray length! For a subarray of length k, each element must exceed threshold / k. This means longer subarrays have more lenient per-element requirements, while shorter subarrays demand higher individual values.

Goal: Return the size of any such valid subarray, or -1 if none exists.

Example: If threshold = 10 and you're checking a subarray of length 2, each element must be > 5. For length 5, each element must be > 2.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 3, 4, 3, 1], threshold = 6

› Output: 3

💡 Note: Subarray [3, 4, 3] has length 3. Each element must be > 6/3 = 2. All elements (3, 4, 3) are greater than 2, so this is valid.

example_2.py — No Valid Subarray

$ Input: nums = [1, 1, 1, 1], threshold = 8

› Output: -1

💡 Note: For any length k, we need each element > 8/k. Since max element is 1, and 8/4 = 2 > 1, no valid subarray exists.

example_3.py — Length 1 Solution

$ Input: nums = [2, 1, 5, 1, 3, 2], threshold = 3

› Output: 1

💡 Note: Element 5 > 3/1 = 3, so subarray [5] of length 1 is valid. This is the smallest valid subarray we can find.

Visualization

Tap to expand

Understanding the Visualization

Budget Distribution

Total budget (threshold) must be distributed among k team members

Individual Requirement

Each member must exceed their allocated budget: threshold/k

Find Optimal Team

Binary search finds the largest team size that meets requirements

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with sliding window validation transforms an O(n³) brute force into an efficient O(n log n) solution by intelligently narrowing the search space.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subarrays, each requiring O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ threshold ≤ 10¹⁵
Note: The threshold can be very large, requiring careful handling of integer division

Asked in

G Google 23 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses binary search on the answer combined with sliding window validation. Instead of checking every possible subarray length linearly, we binary search on lengths from 1 to n. For each candidate length, we use a sliding window to efficiently check if any subarray of that length satisfies the varying threshold condition. This reduces time complexity from O(n³) to O(n log n), making it suitable for large inputs.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Subarrays)	O(n³)	O(1)	Check every possible subarray of every possible length
Binary Search on Answer	O(n log n)	O(1)	Binary search on the subarray length, use sliding window to validate

Brute Force (All Subarrays) — Algorithm Steps

For each possible subarray length k from 1 to n
For each starting position, extract subarray of length k
Check if all elements in subarray > threshold/k
Return the length of first valid subarray found

Visualization

Tap to expand

Step-by-Step Walkthrough

Length 1 Check

Check all subarrays of length 1, each element must be > threshold

Length 2 Check

Check all subarrays of length 2, each element must be > threshold/2

Continue Pattern

Continue for all lengths until valid subarray found

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

int largestSubarray(int* nums, int numsSize, int threshold) {
    // Try all possible subarray lengths
    for (int length = 1; length <= numsSize; length++) {
        double required = (double) threshold / length;
        
        // Try all starting positions for this length
        for (int start = 0; start <= numsSize - length; start++) {
            bool valid = true;
            
            // Check if all elements in subarray > threshold/length
            for (int i = start; i < start + length; i++) {
                if (nums[i] <= required) {
                    valid = false;
                    break;
                }
            }
            
            if (valid) {
                return length;
            }
        }
    }
    
    return -1;
}

int main() {
    int nums[] = {4, 2, 2, 3, 1, 4, 2};
    int threshold = 14;
    printf("%d\n", largestSubarray(nums, 7, threshold));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) subarrays, each requiring O(n) time to validate

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ threshold ≤ 10¹⁵
Note: The threshold can be very large, requiring careful handling of integer division

22.9K Views

Medium-High Frequency

~35 min Avg. Time

847 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 (All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler