Count Elements With Strictly Smaller and Greater Elements

Count Elements With Strictly Smaller and Greater Elements - Problem

Given an integer array nums, return the number of elements that have both a strictly smaller and a strictly greater element appear in nums.

In other words, for each element nums[i], count it if there exists some element nums[j] where nums[j] < nums[i] and some element nums[k] where nums[k] > nums[i].

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: Element 11: has smaller (7,2) and greater (15) ✓. Element 7: has smaller (2) and greater (11,15) ✓. Element 2: has greater (7,11,15) but no smaller ✗. Element 15: has smaller (11,7,2) but no greater ✗. Count = 2

Example 2 — No Valid Elements

$ Input: nums = [6,2,6,5,10,5]

› Output: 4

💡 Note: Min=2, Max=10. Elements between: first 6 (2<6<10), second 6 (2<6<10), first 5 (2<5<10), second 5 (2<5<10). Count = 4

Example 3 — Minimum Size

$ Input: nums = [1,2]

› Output: 0

💡 Note: With only 2 elements, neither can have both smaller and greater elements. Count = 0

Constraints

1 ≤ nums.length ≤ 100
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 8

The key insight is that only elements that are neither the minimum nor maximum value can have both smaller and greater elements. The optimal approach finds min/max in one pass, then counts elements strictly between them. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check Each Element

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

For every element in the array, iterate through all other elements to check if there exists at least one smaller element and at least one greater element. Count elements that satisfy both conditions.

Sort First - Find Min/Max

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

First find the minimum and maximum values in the array. Then count how many elements are strictly between these extremes. Elements equal to min or max cannot have both smaller and greater elements.

Brute Force - Check Each Element — Algorithm Steps

Iterate through each element
For each element, scan all others to find smaller and greater
Count elements that have both conditions satisfied

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Element

Pick current element to check

Scan Array

Compare with all elements to find smaller/greater

Count Valid

Increment count if both conditions met

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int count = 0;
    for (int i = 0; i < numsSize; i++) {
        int hasSmaller = 0;
        int hasGreater = 0;
        
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] < nums[i]) {
                hasSmaller = 1;
            }
            if (nums[j] > nums[i]) {
                hasGreater = 1;
            }
        }
        
        if (hasSmaller && hasGreater) {
            count++;
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, numsSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan through all n elements to find smaller/greater

✓ Linear Growth

Space Complexity

O(1)

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

✓ Linear Space

15.0K Views

Medium Frequency

~15 min Avg. Time

445 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

Brute Force - Check Each Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler