# Count of Subarrays of given Array with median at least X

Given an array **arr[]**of integers with length **N **and an integer** X**, the task is to calculate the number of subarrays with median greater than or equal to the given integer **X**.

**Examples:**

Input:N=4, A = [5, 2, 4, 1], X = 4Output:7Explanation:For subarray [5], median is 5. (>= 4)

For subarray [5, 2], median is 5. (>= 4)

For subarray [5, 2, 4], median is 4. (>= 4)

For subarray [5, 2, 4, 1], median is 4. (>= 4)

For subarray [2, 4], median is 4. (>= 4)

For subarray [4], median is 4. (>= 4)

For subarray [4, 1], median is 4. (>= 4)

Input:N = [3, 7, 2, 0, 1, 5], X = 10Output:0Explanation:There are no subarrays with median greater than or equal to X.

**Approach: ** The problem can be solved based on the following idea.

To find a subarray with median greater or equal to X at least half of the elements should be greater than or equal to X.

Follow the below steps to implement the above idea:

- Replace each element of an array with
**1**if it is greater than or equal to**X**, else replace it with**-1**. - Based on the above idea, for the new array, median of any subarray to be greater than or equal to
**X**, its sum of elements should be greater than or equal to 0. - For calculating the number of subarray with a sum greater than or equal to 0:
- Find
**prefix sum**up to each index of the new array. - Traverse the newly created prefix array starting from index
**1**and calculate the number of elements before it with a value less than or equal to the current value. - Add all those in the final answer as they will also form a subarray with the current one satisfying all conditions.
- After finding it for an index, add the current value to a
**multiset**.

- Find
- Return the final answer.

**Note**: For efficiently calculating the number of elements with a value less than or equal to **Y**, use policy-based data structures.

Below is the implementation of the above approach:

## C++

`// C++ code to implement the above approach` `#include <ext/pb_ds/assoc_container.hpp>` `#include <ext/pb_ds/tree_policy.hpp>` `#include <functional>` `#include <iostream>` `using` `namespace` `__gnu_pbds;` `using` `namespace` `std;` `// A new data structure defined.` `typedef` `tree<` `int` `, null_type, less_equal<` `int` `>, rb_tree_tag,` ` ` `tree_order_statistics_node_update>` ` ` `ordered_set;` `// Function to to find the Number of` `// subarrays with median greater than` `// or equal to X.` `long` `long` `findNumberOfSubarray(` `int` `arr[],` ` ` `int` `n, ` `int` `X)` `{` ` ` `// Build new array by comparing it with X` ` ` `int` `new_array[n];` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `if` `(arr[i] >= X) {` ` ` `new_array[i] = 1;` ` ` `}` ` ` `else` `{` ` ` `new_array[i] = -1;` ` ` `}` ` ` `}` ` ` `// Build new array in which` ` ` `// at i-th index, Sum of first i elements` ` ` `// are stored` ` ` `int` `pref_sum[n];` ` ` `pref_sum[0] = new_array[0];` ` ` `for` `(` `int` `i = 1; i < n; i++) {` ` ` `pref_sum[i] = pref_sum[i - 1]` ` ` `+ new_array[i];` ` ` `}` ` ` `// Store the answer` ` ` `// Using long long because` ` ` `// it can exceed the storage limit of int` ` ` `long` `long` `ans = 0;` ` ` `// For storing already traversed values` ` ` `ordered_set s;` ` ` `s.insert(0);` ` ` `// Iterating forwards from 0 to n-1.` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `int` `less_than` ` ` `= s.order_of_key(pref_sum[i] + 1);` ` ` `ans += less_than;` ` ` `s.insert(pref_sum[i]);` ` ` `}` ` ` `return` `ans;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `N = 4, X = 4;` ` ` `int` `arr[] = { 5, 2, 4, 1 };` ` ` `// Function call` ` ` `long` `long` `ans` ` ` `= findNumberOfSubarray(arr, N, X);` ` ` `cout << ans;` ` ` `return` `0;` `}` |

## Python3

`# python3 code to implement the above approach` `import` `bisect` `# Function to to find the Number of` `# subarrays with median greater than` `# or equal to X.` `def` `findNumberOfSubarray(arr, n, X):` ` ` `# Build new array by comparing it with X` ` ` `new_array ` `=` `[` `0` `for` `_ ` `in` `range` `(n)]` ` ` `for` `i ` `in` `range` `(` `0` `, n):` ` ` `if` `(arr[i] >` `=` `X):` ` ` `new_array[i] ` `=` `1` ` ` `else` `:` ` ` `new_array[i] ` `=` `-` `1` ` ` `# Build new array in which` ` ` `# at i-th index, Sum of first i elements` ` ` `# are stored` ` ` `pref_sum ` `=` `[` `0` `for` `_ ` `in` `range` `(n)]` ` ` `pref_sum[` `0` `] ` `=` `new_array[` `0` `]` ` ` `for` `i ` `in` `range` `(` `1` `, n):` ` ` `pref_sum[i] ` `=` `pref_sum[i ` `-` `1` `] ` `+` `new_array[i]` ` ` `# Store the answer` ` ` `# Using long long because` ` ` `# it can exceed the storage limit of int` ` ` `ans ` `=` `0` ` ` `# For storing already traversed values` ` ` `s ` `=` `set` `()` ` ` `s.add(` `0` `)` ` ` `# Iterating forwards from 0 to n-1.` ` ` `for` `i ` `in` `range` `(` `0` `, n):` ` ` `less_than ` `=` `bisect.bisect_left(` ` ` `sorted` `(s), pref_sum[i]` `+` `1` `, lo` `=` `0` `, hi` `=` `len` `(s))` ` ` `if` `pref_sum[i] ` `+` `1` `in` `s:` ` ` `less_than ` `+` `=` `1` ` ` `ans ` `+` `=` `less_than` ` ` `s.add(pref_sum[i])` ` ` `return` `ans` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `N, X ` `=` `4` `, ` `4` ` ` `arr ` `=` `[` `5` `, ` `2` `, ` `4` `, ` `1` `]` ` ` `# Function call` ` ` `ans ` `=` `findNumberOfSubarray(arr, N, X)` ` ` `print` `(ans)` ` ` `# This code is contributed by rakeshsahni` |

**Output**

7

**Time Complexity: **O(N * logN)**Auxiliary Space: **O(N)