Count of Subarrays of given Array with median at least X

// javascript code to implement the above approach

// Function to find the Number of
// subarrays with median greater than
// or equal to X.
function findNumberOfSubarray(arr, n, X) {


    // Build new array by comparing it with X
    let new_array = Array(n).fill(0);

    for (let 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
    let pref_sum = Array(n).fill(0);
    pref_sum[0] = new_array[0];
    for (let i = 1; i < n; i++) {
        pref_sum[i] = pref_sum[i - 1] + new_array[i];
    }

    // Store the answer
    // Using BigInt because it can exceed the storage limit of int
    let ans = BigInt(0);

    // For storing already traversed values
    let s = new Set();
    s.add(0);

    // Iterating forwards from 0 to n-1.
    for (let i = 0; i < n; i++) {

        // less_than = bisect.bisect_left(sorted(s), pref_sum[i]+1, lo=0, hi=len(s))
        let sortedS = Array.from(s).sort(function(a, b) {
            return a - b
        });
        let less_than = bisect_left(sortedS, pref_sum[i] + 1, 0, sortedS.length);
        if (s.has(pref_sum[i] + 1)) {
            less_than += 1;
        }
        ans += BigInt(less_than);
        s.add(pref_sum[i]);
    }

    return ans;

}

// binary search equivalent to Python's bisect.bisect_left
function bisect_left(sortedArr, x, lo, hi) {
    lo = lo || 0;
    hi = hi || sortedArr.length;
    while (lo < hi) {
        let mid = (lo + hi) >>> 1;
        if (sortedArr[mid] < x) {
            lo = mid + 1;
        } else {
            hi = mid;
        }
    }
    return lo;
}

// Driver Code
let N = 4,
    X = 4;
let arr = [5, 2, 4, 1];

// Function call
let ans = findNumberOfSubarray(arr, N, X);
console.log(ans);

// This code is contributed by phasing17