Codestin Search App

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 log n)

O(log n) binary search iterations, each requiring O(n) sliding window validation

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space for binary search 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
✓ 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)	O(n³)	O(1)	Check every possible subarray of every possible length

Binary Search on Answer — Algorithm Steps

Binary search on the subarray length from 1 to n
For each length, calculate required threshold per element
Use sliding window to check if any subarray of this length is valid
If valid subarray exists, try larger lengths; otherwise try smaller

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Search space: length 1 to n

Test Middle

Check if subarray of length mid exists

Narrow Search

If found, search for larger; if not, search smaller

Code -

solution.c — C

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

bool canFindSubarray(int* nums, int numsSize, int threshold, int length) {
    if (length == 0) return false;
    
    double required = (double) threshold / length;
    
    // Use sliding window to check all subarrays of this length
    for (int start = 0; start <= numsSize - length; start++) {
        bool valid = true;
        for (int i = start; i < start + length; i++) {
            if (nums[i] <= required) {
                valid = false;
                break;
            }
        }
        if (valid) return true;
    }
    return false;
}

int largestSubarray(int* nums, int numsSize, int threshold) {
    int left = 1, right = numsSize;
    int result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canFindSubarray(nums, numsSize, threshold, mid)) {
            result = mid;
            left = mid + 1;  // Try to find larger valid subarray
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

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 log n)

O(log n) binary search iterations, each requiring O(n) sliding window validation

⚡ Linearithmic

Space Complexity

O(1)

Only constant extra space for binary search 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

Binary Search on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler