Count Elements With Strictly Smaller and Greater Elements

Count Elements With Strictly Smaller and Greater Elements - Problem

Given an integer array nums, you need to find how many elements have both a strictly smaller element and a strictly greater element present somewhere in the array.

In other words, for each element nums[i], count it only if there exists at least one element in the array that is strictly smaller than nums[i] AND at least one element that is strictly greater than nums[i].

Example: In array [11, 7, 2, 15], elements 11 and 7 satisfy this condition:

11 has 7, 2 (smaller) and 15 (greater)
7 has 2 (smaller) and 11, 15 (greater)
2 has no smaller element
15 has no greater element

So the answer is 2.

Input & Output

example_1.py — Basic Case

$ Input: [11,7,2,15]

› Output: 2

💡 Note: Element 11 has smaller elements (7,2) and greater element (15). Element 7 has smaller element (2) and greater elements (11,15). Elements 2 and 15 are min/max so they can't have both conditions.

example_2.py — All Same Elements

$ Input: [6,6,6,6]

› Output: 0

💡 Note: All elements are equal, so no element has both a strictly smaller and strictly greater element in the array.

example_3.py — Small Array

$ Input: [1,2]

› Output: 0

💡 Note: With only 2 elements, neither can have both smaller and greater elements. Each element can have at most one of the two conditions.

Visualization

Tap to expand

Understanding the Visualization

Line Up All Players

Arrange all team members to see their heights: [2, 7, 11, 15]

Identify Extremes

Find the shortest (2) and tallest (15) players - they can't satisfy our condition

Count Middle Players

Players with heights 7 and 11 have both shorter and taller teammates

Final Count

2 players satisfy the condition of having both shorter and taller teammates

Key Takeaway

🎯 Key Insight: Only elements that are neither minimum nor maximum can have both smaller and greater elements in the array!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array: one to find min/max, another to count valid elements

✓ Linear Growth

Space Complexity

O(1)

Only storing min, max, and count variables

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
The array must contain at least 3 elements for any valid answers

Asked in

G Google 12 a Amazon 8 f Meta 6 ⊞ Microsoft 5

The optimal solution uses the min-max approach with O(n) time complexity. Key insight: only elements that are strictly between the minimum and maximum values can have both smaller and greater elements. Find min/max in one pass, then count elements in the valid range.

Common Approaches

Approach	Time	Space	Notes
✓ Min-Max Approach (Optimal)	O(n)	O(1)	Find min and max values, then count elements strictly between them
Brute Force (Nested Loops)	O(n²)	O(1)	For each element, scan the entire array to find smaller and greater elements

Min-Max Approach (Optimal) — Algorithm Steps

Find the minimum and maximum values in the array
Iterate through the array once more
Count elements that are strictly greater than min AND strictly less than max
Return the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Min and Max

Identify the minimum and maximum values in the array

Set Boundaries

Elements equal to min/max cannot have both smaller and greater

Count Middle Elements

Count elements strictly between min and max

Return Result

All counted elements satisfy the condition

Code -

solution.c — C

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

int countElements(int* nums, int numsSize) {
    if (numsSize < 3) {
        return 0;
    }
    
    int minVal = INT_MAX;
    int maxVal = INT_MIN;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] < minVal) {
            minVal = nums[i];
        }
        if (nums[i] > maxVal) {
            maxVal = nums[i];
        }
    }
    
    int count = 0;
    for (int i = 0; i < numsSize; i++) {
        if (minVal < nums[i] && nums[i] < maxVal) {
            count++;
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9' || c == '-') {
            ungetc(c, stdin);
            scanf("%d", &nums[size++]);
        }
    }
    
    printf("%d\n", countElements(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Two passes through the array: one to find min/max, another to count valid elements

✓ Linear Growth

Space Complexity

O(1)

Only storing min, max, and count variables

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 100
-100 ≤ nums[i] ≤ 100
The array must contain at least 3 elements for any valid answers

28.6K Views

Medium Frequency

~12 min Avg. Time

892 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

Min-Max Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler