Special Array With X Elements Greater Than or Equal X

Special Array With X Elements Greater Than or Equal X - Problem

Imagine you're organizing a unique contest where participants are ranked by their scores. You have an array nums containing non-negative integers representing these scores.

The array is considered special if there exists a magic number x such that exactly x participants have scores greater than or equal to x.

Important: The value x doesn't need to be one of the actual scores in the array - it's just a threshold value!

Goal: Find and return this special value x if it exists, otherwise return -1. If the array is special, this value is guaranteed to be unique.

Example: In array [3, 5], we have exactly 2 numbers ≥ 2, making x = 2 our answer!

Input & Output

example_1.py — Basic Case

$ Input: [3, 5]

› Output: 2

💡 Note: There are exactly 2 numbers in the array that are >= 2 (both 3 and 5 are >= 2). Since the count equals x, the answer is x = 2.

example_2.py — No Special Value

$ Input: [0, 0]

› Output: -1

💡 Note: For x=0: 2 elements >= 0, but 2 ≠ 0. For x=1: 0 elements >= 1, but 0 ≠ 1. For x=2: 0 elements >= 2, but 0 ≠ 2. No valid x exists.

example_3.py — Edge Case

$ Input: [0, 4, 3, 0, 4]

› Output: 3

💡 Note: There are exactly 3 numbers >= 3 in the array (4, 3, 4). Since count = x = 3, this is our special value.

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 1000
The array contains only non-negative integers
If a special value exists, it is guaranteed to be unique

Visualization

Tap to expand

Understanding the Visualization

Set Threshold

Choose a threshold value x (0 to n)

Count Elements

Count how many array elements are ≥ x

Check Balance

Does the count equal our threshold x?

Find Equilibrium

If count = x, we found the special value!

Key Takeaway

🎯 Key Insight: The special value x creates a perfect equilibrium where exactly x elements meet or exceed the threshold x. Since x can only range from 0 to n, we only need to check a limited number of possibilities!

Asked in

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

The optimal solution uses a simple brute force approach that tries all possible values of x from 0 to n. For each x, it counts elements ≥ x and checks if count equals x. While sorting + binary search offers theoretical improvements, the brute force O(n²) solution is most practical given the constraint that n ≤ 100, making it both simple and efficient for this problem size.

Common Approaches

Approach	Time	Space	Notes
✓ Sorting + Binary Search	O(n log n)	O(1)	Sort array first, then use binary search to efficiently count elements >= x
Sorting + Smart Iteration	O(n log n)	O(1)	Sort array and iterate through possible x values with optimized counting
Brute Force (Check All Possibilities)	O(n²)	O(1)	Try every possible value of x from 0 to n and count elements >= x

Sorting + Binary Search — Algorithm Steps

Sort the array in descending order for easier counting
Try each possible value of x from 0 to n
For each x, use binary search to find the count of elements >= x
If count equals x, return x; otherwise continue
If no valid x found, return -1

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort in descending order: [5,4,3,2]

Binary Search

For each x, binary search to count elements >= x

Compare

Check if count equals x

Optimize

Binary search reduces counting from O(n) to O(log n)

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int countGreaterEqual(int* nums, int numsSize, int x) {
    // Binary search to find count of elements >= x
    int left = 0, right = numsSize;
    while (left < right) {
        int mid = (left + right) / 2;
        if (nums[mid] >= x) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int specialArray(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), compare);
    
    // Try all possible values of x
    for (int x = 0; x <= numsSize; x++) {
        int count = countGreaterEqual(nums, numsSize, x);
        if (count == x) {
            return x;
        }
    }
    return -1;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int inNumber = 0;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
            inNumber = 1;
        } else if (inNumber) {
            nums[size++] = num;
            num = 0;
            inNumber = 0;
        }
    }
    if (inNumber) {
        nums[size++] = num;
    }
    
    printf("%d\n", specialArray(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting plus O(n log n) for n binary searches, dominated by sorting

⚡ Linearithmic

Space Complexity

O(1)

Sorting in-place, only using constant extra space for variables

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Sorting + Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler