Skip to content

2148. Count Elements With Strictly Smaller and Greater Elements

Description

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

 

Example 1:

Input: nums = [11,7,2,15]
Output: 2
Explanation: The element 7 has the element 2 strictly smaller than it and the element 11 strictly greater than it.
Element 11 has element 7 strictly smaller than it and element 15 strictly greater than it.
In total there are 2 elements having both a strictly smaller and a strictly greater element appear in nums.

Example 2:

Input: nums = [-3,3,3,90]
Output: 2
Explanation: The element 3 has the element -3 strictly smaller than it and the element 90 strictly greater than it.
Since there are two elements with the value 3, in total there are 2 elements having both a strictly smaller and a strictly greater element appear in nums.

 

Constraints:

  • 1 <= nums.length <= 100
  • -105 <= nums[i] <= 105

Solutions

Solution 1: Find Minimum and Maximum Values

According to the problem description, we can first find the minimum value \(\textit{mi}\) and the maximum value \(\textit{mx}\) of the array \(\textit{nums}\). Then, traverse the array \(\textit{nums}\) and count the number of elements that satisfy \(\textit{mi} < x < \textit{mx}\).

The time complexity is \(O(n)\), where \(n\) is the length of the array \(\textit{nums}\). The space complexity is \(O(1)\).

1
2
3
4
class Solution:
    def countElements(self, nums: List[int]) -> int:
        mi, mx = min(nums), max(nums)
        return sum(mi < x < mx for x in nums)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class Solution {
    public int countElements(int[] nums) {
        int mi = Arrays.stream(nums).min().getAsInt();
        int mx = Arrays.stream(nums).max().getAsInt();
        int ans = 0;
        for (int x : nums) {
            if (mi < x && x < mx) {
                ans++;
            }
        }
        return ans;
    }
}

1
2
3
4
5
6
7
class Solution {
public:
    int countElements(vector<int>& nums) {
        auto [mi, mx] = ranges::minmax_element(nums);
        return ranges::count_if(nums, [mi, mx](int x) { return *mi < x && x < *mx; });
    }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
func countElements(nums []int) (ans int) {
    mi := slices.Min(nums)
    mx := slices.Max(nums)
    for _, x := range nums {
        if mi < x && x < mx {
            ans++
        }
    }
    return
}

1
2
3
4
5
function countElements(nums: number[]): number {
    const mi = Math.min(...nums);
    const mx = Math.max(...nums);
    return nums.filter(x => mi < x && x < mx).length;
}

Comments