Count the Number of K-Big Indices - Practice Coding Problems

Count the Number of K-Big Indices - Problem

Array Binary Search Divide and Conquer Binary Indexed Tree Segment Tree Merge Sort Ordered Set Hard

Count the Number of K-Big Indices

Imagine you're analyzing stock prices or performance ratings where you need to identify "standout" positions. You're given a 0-indexed integer array nums and a positive integer k.

An index i is considered k-big if it satisfies both conditions:
• There are at least k different indices to the left of i where nums[idx] < nums[i]
• There are at least k different indices to the right of i where nums[idx] < nums[i]

Your goal is to return the total count of k-big indices in the array.

Example: For nums = [2,3,6,5,2,3] and k = 2, index 2 (value 6) has 2 smaller elements on its left [2,3] and 2 smaller elements on its right [5,2], making it k-big.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Only index 2 (value 6) is k-big. It has indices [0,1] with smaller values on the left and indices [3,4] with smaller values on the right, both counts are ≥ 2.

example_2.py — No Valid Indices

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

› Output: 0

💡 Note: No index can be k-big because we need at least 3 smaller elements on each side, but we only have 3 elements total.

example_3.py — Multiple Valid Indices

$ Input: nums = [1,2,5,4,3,6,7,8,1,2], k = 2

› Output: 3

💡 Note: Indices 6, 7, and possibly others satisfy the k-big condition with at least 2 smaller elements on both sides.

Visualization

Tap to expand

Understanding the Visualization

Survey the Range

We examine each mountain peak (array element) one by one

Count Left Visibility

For each peak, count how many lower peaks are visible to the left

Count Right Visibility

Similarly, count lower peaks visible to the right

Identify Significant Peaks

Peaks with ≥k visibility in both directions are k-significant

Key Takeaway

🎯 Key Insight: We need efficient data structures like Fenwick Trees to avoid repeatedly counting smaller elements, reducing time complexity from O(n²) to O(n log n)

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we potentially scan up to n elements on each side

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ nums.length
Performance requirement: Solution should handle maximum constraints efficiently

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

This problem requires efficiently counting smaller elements on both sides of each index. The optimal solution uses a Fenwick Tree with coordinate compression to achieve O(n log n) time complexity. The key insight is performing two passes: left-to-right and right-to-left, using the tree to maintain running counts of elements seen so far.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	For each index, count smaller elements on both sides using nested loops
Fenwick Tree / Binary Indexed Tree	O(n log n)	O(n)	Use Fenwick Tree to efficiently count smaller elements on both sides

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each index i from 0 to n-1
Count elements to the left of i that are smaller than nums[i]
Count elements to the right of i that are smaller than nums[i]
If both counts >= k, increment the result counter
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Index

Choose current index i to evaluate

Count Left

Scan all indices left of i, count smaller values

Count Right

Scan all indices right of i, count smaller values

Check Condition

If both counts >= k, increment result

Code -

solution.c — C

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

int kBigIndices(int* nums, int numsSize, int k) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        // Count smaller elements to the left
        int leftCount = 0;
        for (int j = 0; j < i; j++) {
            if (nums[j] < nums[i]) {
                leftCount++;
            }
        }
        
        // Count smaller elements to the right
        int rightCount = 0;
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[j] < nums[i]) {
                rightCount++;
            }
        }
        
        // Check if both conditions are satisfied
        if (leftCount >= k && rightCount >= k) {
            count++;
        }
    }
    
    return count;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we potentially scan up to n elements on each side

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ nums.length
Performance requirement: Solution should handle maximum constraints efficiently

28.4K Views

Medium Frequency

~35 min Avg. Time

865 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler