Count the Number of K-Big Indices - Problem

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

You are given a 0-indexed integer array nums and a positive integer k.

We call an index i k-big if the following conditions are satisfied:

There exist at least k different indices idx1 such that idx1 < i and nums[idx1] < nums[i].
There exist at least k different indices idx2 such that idx2 > i and nums[idx2] < nums[i].

Return the number of k-big indices.

Input & Output

Example 1 — Basic Case

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

› Output: 1

💡 Note: Only index 2 (value 5) is k-big: it has 2 smaller elements on left [2,3] and 2 smaller elements on right [1,4]

Example 2 — No K-Big Indices

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

› Output: 0

💡 Note: No index can have 3 smaller elements on both sides since all elements are equal and array has only 3 elements

Example 3 — Multiple K-Big Indices

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

› Output: 4

💡 Note: Indices 1,2,3,4 are k-big: each has at least 1 smaller element on left and 1 smaller element on right

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is that an index is k-big if it has at least k smaller elements on both its left and right sides. The brute force approach checks each index by counting smaller elements on both sides in O(n³) time. A better approach uses two passes to precompute left and right counts in O(n²) time. For optimal performance, advanced data structures like Binary Indexed Trees can achieve O(n log n) time.

Common Approaches

✓ Brute Force

⏱️ Time: O(n³) Space: O(1)

For every index i, iterate through all indices to the left to count elements smaller than nums[i], then iterate through all indices to the right to count elements smaller than nums[i]. If both counts are at least k, increment the result.

Two-Pass Counting

⏱️ Time: O(n²) Space: O(n)

Make two passes through the array. In the first pass, for each index, count how many smaller elements exist to its left. In the second pass, count how many smaller elements exist to its right. Then check each index to see if both counts are at least k.

Brute Force — Algorithm Steps

Step 1: For each index i, count elements j < i where nums[j] < nums[i]
Step 2: Count elements j > i where nums[j] < nums[i]
Step 3: If both counts >= k, increment result

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Index

Pick current index i to check

Count Left

Count elements j < i where nums[j] < nums[i]

Count Right

Count elements j > i where nums[j] < nums[i]

Code -

solution.c — C

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

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

int main() {
    static int nums[1000];
    int numsSize = 0;
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array using strtol
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        char* endptr;
        long val = strtol(p, &endptr, 10);
        if (p != endptr) {
            nums[numsSize++] = (int)val;
            p = endptr;
        } else {
            break;
        }
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: outer loop for each index, two inner loops to count smaller elements on left and right

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for counting

⚡ Linearithmic Space

8.5K Views

Medium Frequency

~25 min Avg. Time

342 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

Count the Number of K-Big Indices - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler