Count of Array elements greater than or equal to twice the Median of K trailing Array elements

Last Updated : 11 Oct, 2023

Given an array A[] of size greater than integer K, the task is to find the total number of elements from the array which are greater than or equal to twice the median of K trailing elements in the given array.

Examples:

Input: A[] = {10, 20, 30, 40, 50}, K = 3
Output: 1
Explanation:
Since K = 3, the only two elements to be checked are {40, 50}.
For 40, the median of 3 trailing numbers {10, 20, 30} is 20.
Since 40 = 2 * 20, 40 is counted.
For element 50 the median of 3 trailing numbers {20, 30, 40} is 30.
Since 50 < 2 * 30, so 50 is not counted.
Therefore, the answer is 1.

Input: A[] = {1, 2, 2, 4, 5}, K = 3
Output: 2
Explanation:
Since K = 3, the only two elements considered are {4, 5}.
For 4, the median of 3 trailing numbers {1, 2, 2} is 2.
Since 4 = 2 * 2, therefore, 4 is counted.
For 5 the median of 3 trailing numbers {2, 2, 4} is 2.
5 > 2 * 2, so 5 is counted.
Therefore, the answer is 2.

Naive Approach:
Follow the steps below to solve the problem:

Iterate over the given array from K + 1 to the size of the array and for each element, add the previous K elements from the array.
Then, find the median and check if the current element is equal to or exceeds twice the value of the median. If found to be true, increase the count.
Finally. print the count.

Below is the implementation of the above approach:

C++14

   // C++ Program to implement the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the count of
// array elements >= twice the median
// of K trailing array elements
void solve(int n, int k, int input[])
{
    // count to store ans
    int count = 0;
 
    // Iterating from k to n-1 index means
    // (k+1)th element to nth element
    for (int i = k; i < n; i++) {
 
        // temp to store the trailing k elements
        int temp[k];
        for (int j = 0; j < k; j++) {
            temp[j] = input[i - k + j];
        }
 
        // sort the array temp and
        // to find its median
        sort(temp, temp + k);
 
        int median;
 
        // find the median
        if (k % 2 == 0) {
            median = (temp[k / 2 - 1] + temp[k / 2]) / 2;
        }
        else {
            median = temp[k / 2];
        }
 
        // If the current >= 2 * median
        if (input[i] >= 2 * median) {
            count++;
        }
    }
 
    // Print the count
    cout << count << endl;
}
 
// Driver Code
int main()
{
    int input[] = { 1, 2, 2, 4, 5 };
    int n = sizeof input / sizeof input[0];
    int k = 3;
 
    solve(n, k, input);
 
    return 0;
}
 
  

Java

   import java.util.Arrays;
 
public class MedianComparison {
    // Function to find the count of
    // array elements >= twice the median
    // of K trailing array elements
    public static void solve(int n, int k, int[] input) {
        // Count to store the answer
        int count = 0;
 
        // Iterating from k to n-1 index means
        // (k+1)th element to nth element
        for (int i = k; i < n; i++) {
            // Temp array to store the trailing k elements
            int[] temp = new int[k];
            for (int j = 0; j < k; j++) {
                temp[j] = input[i - k + j];
            }
 
            // Sort the temp array to find its median
            Arrays.sort(temp);
 
            int median;
 
            // Find the median
            if (k % 2 == 0) {
                median = (temp[k / 2 - 1] + temp[k / 2]) / 2;
            } else {
                median = temp[k / 2];
            }
 
            // If the current element is >= 2 * median
            if (input[i] >= 2 * median) {
                count++;
            }
        }
 
        // Print the count
        System.out.println(count);
    }
 
    // Driver Code
    public static void main(String[] args) {
        int[] input = { 1, 2, 2, 4, 5 };
        int n = input.length;
        int k = 3;
 
        solve(n, k, input);
    }
}
 
// This code is contributed by akshitaguprzj3
 
  

Python

   # Python Program to implement the above approach
 
def solve(n, k, input_array):
    # count to store ans
    count = 0
 
    # Iterating from k to n-1 index means
    # (k+1)th element to nth element
    for i in range(k, n):
 
        # temp to store the trailing k elements
        temp = input_array[i - k:i]
 
        # sort the array temp and
        # to find its median
        temp.sort()
 
        median = 0
 
        # find the median
        if k % 2 == 0:
            median = (temp[k // 2 - 1] + temp[k // 2]) / 2
        else:
            median = temp[k // 2]
 
        # If the current >= 2 * median
        if input_array[i] >= 2 * median:
            count += 1
 
    # Print the count
    print(count)
 
# Driver Code
if __name__ == "__main__":
    input_array = [1, 2, 2, 4, 5]
    n = len(input_array)
    k = 3
 
    solve(n, k, input_array)
 
  

C#

   using System;
 
class Program
{
    // Function to find the count of
    // array elements >= twice the median
    // of K trailing array elements
    static void Solve(int n, int k, int[] input)
    {
        // Count to store ans
        int count = 0;
 
        // Iterating from k to n-1 index means
        // (k+1)th element to nth element
        for (int i = k; i < n; i++)
        {
            // Temp array to store the trailing k elements
            int[] temp = new int[k];
            for (int j = 0; j < k; j++)
            {
                temp[j] = input[i - k + j];
            }
 
            // Sort the array temp and
            // to find its median
            Array.Sort(temp);
 
            int median;
 
            // Find the median
            if (k % 2 == 0)
            {
                median = (temp[k / 2 - 1] + temp[k / 2]) / 2;
            }
            else
            {
                median = temp[k / 2];
            }
 
            // If the current >= 2 * median
            if (input[i] >= 2 * median)
            {
                count++;
            }
        }
 
        // Print the count
        Console.WriteLine(count);
    }
 
    // Driver Code
    static void Main()
    {
        int[] input = { 1, 2, 2, 4, 5 };
        int n = input.Length;
        int k = 3;
 
        Solve(n, k, input);
    }
}
// This code is contributed by akshitaguprzj3
 
  

Javascript

   // Function to find the count of
// array elements >= twice the median
// of K trailing array elements
function solve(n, k, input) {
    // count to store ans
    let count = 0;
 
    // Iterating from k to n-1 index means
    // (k+1)th element to nth element
    for (let i = k; i < n; i++) {
        // temp to store the trailing k elements
        let temp = [];
        for (let j = 0; j < k; j++) {
            temp.push(input[i - k + j]);
        }
 
        // sort the array temp and
        // to find its median
        temp.sort((a, b) => a - b);
 
        let median;
 
        // find the median
        if (k % 2 === 0) {
            median = (temp[k / 2 - 1] + temp[k / 2]) / 2;
        } else {
            median = temp[Math.floor(k / 2)];
        }
 
        // If the current >= 2 * median
        if (input[i] >= 2 * median) {
            count++;
        }
    }
 
    // Print the count
    console.log(count);
}
 
// Driver Code
let input = [1, 2, 2, 4, 5];
let n = input.length;
let k = 3;
 
solve(n, k, input);
 
// This code is contributed by akshitaguprzj3
 
  

Output

Time Complexity: O(N * K * log K), Where N is the size of the input array and sorting requires (K * log K).
Auxiliary Space: O(K), Where K is the size of the temp array.

Efficient Approach:
To optimize the above approach, the idea is to use frequency-counting and sliding window technique. Follow the steps below to solve the problem:

Store the frequencies of the elements present in the first K indices.
Iterate over the array from (k + 1)^th index to the N^th index and for each iteration, decrease the frequency of the i – k^th element where i is the current index of the previous K trailing elements and increase the frequency count of the current element.
For each iteration obtain the value of the low median and high median which will be different if the K is even. Otherwise it will be the same.
Initialize a count variable that will count the frequency. Whenever floor((k+1)/2) is reached, the count gives a low median and similarly when the count reaches to ceil((k+1)/2) then it gives high median.
Then add both the low and high median value and check if the current value is greater than or equal to it or and accordingly update the answer.

Below is the implementation of the above approach:

C++

   // C++ Program to implement the above approach
#include <bits/stdc++.h>
using namespace std;
 
const int N = 2e5;
const int V = 500;
 
// Function to find the count of array elements >= twice the
// median of K trailing array elements
void solve(int n, int d, int input[])
{
    int a[N];
 
    // Stores frequencies
    int cnt[V + 1];
 
    // Stores the array elements
    for (int i = 0; i < n; ++i)
        a[i] = input[i];
 
    int answer = 0;
 
    // Count the frequencies of the array elements
    for (int i = 0; i < d; ++i)
        cnt[a[i]]++;
 
    // Iterating from d to n-1 index means (d+1)th element
    // to nth element
    for (int i = d; i <= n - 1; ++i) {
 
        // To check the median
        int acc = 0;
 
        int low_median = -1, high_median = -1;
 
        // Iterate over the frequencies of the elements
        for (int v = 0; v <= V; ++v) {
 
            // Add the frequencies
            acc += cnt[v];
 
            // Check if the low_median value is obtained or
            // not, if yes then do not change as it will be
            // minimum
            if (low_median == -1
                && acc >= int(floor((d + 1) / 2.0)))
                low_median = v;
 
            // Check if the high_median value is obtained or
            // not, if yes then do not change it as it will
            // be maximum
            if (high_median == -1 && acc >= int(ceil((d + 1) / 2.0)))
                high_median = v;
        }
 
        // Store 2 * median of K trailing elements
        int double_median = low_median + high_median;
 
        // If the current >= 2 * median
        if (a[i] >= double_median)
            answer++;
 
        // Decrease the frequency for (k-1)-th element
        cnt[a[i - d]]--;
 
        // Increase the frequency of the current element
        cnt[a[i]]++;
    }
 
    // Print the count
    cout << answer << endl;
}
 
// Driver Code
int main()
{
    int input[] = { 1, 2, 2, 4, 5 };
    int n = sizeof input / sizeof input[0];
    int k = 3;
 
    solve(n, k, input);
 
    return 0;
}
 
// This code is contributed by Sania Kumari Gupta
 
  

C

   // C Program to implement the above approach
#include <stdio.h>
#include <math.h>
 
const int N = 2e5;
const int V = 500;
 
// Function to find the count of array elements >= twice the
// median of K trailing array elements
void solve(int n, int d, int input[])
{
    int a[N];
 
    // Stores frequencies
    int cnt[V + 1];
 
    // Stores the array elements
    for (int i = 0; i < n; ++i)
        a[i] = input[i];
 
    int answer = 0;
 
    // Count the frequencies of the array elements
    for (int i = 0; i < d; ++i)
        cnt[a[i]]++;
 
    // Iterating from d to n-1 index means (d+1)th element
    // to nth element
    for (int i = d; i <= n - 1; ++i) {
 
        // To check the median
        int acc = 0;
 
        int low_median = -1, high_median = -1;
 
        // Iterate over the frequencies of the elements
        for (int v = 0; v <= V; ++v) {
 
            // Add the frequencies
            acc += cnt[v];
 
            // Check if the low_median value is obtained or
            // not, if yes then do not change as it will be
            // minimum
            if (low_median == -1 && acc >= floor((d + 1) / 2.0))
                low_median = v;
 
            // Check if the high_median value is obtained or
            // not, if yes then do not change it as it will
            // be maximum
            if (high_median == -1 && acc >= ceil((d + 1) / 2.0))
                high_median = v;
        }
 
        // Store 2 * median of K trailing elements
        int double_median = low_median + high_median;
 
        // If the current >= 2 * median
        if (a[i] >= double_median)
            answer++;
 
        // Decrease the frequency for (k-1)-th element
        cnt[a[i - d]]--;
 
        // Increase the frequency of the current element
        cnt[a[i]]++;
    }
 
    // Print the count
    printf("%d",answer);
}
 
// Driver Code
int main()
{
    int input[] = { 1, 2, 2, 4, 5 };
    int n = sizeof input / sizeof input[0];
    int k = 3;
 
    solve(n, k, input);
 
    return 0;
}
 
// This code is contributed by Sania Kumari Gupta
 
  

Java

   // Java Program to implement
// the above approach
class GFG{
 
static int N = (int) 2e5;
static int V = 500;
 
// Function to find the count of array
// elements >= twice the median of K
// trailing array elements
static void solve(int n, int d, int input[])
{
    int []a = new int[N];
 
    // Stores frequencies
    int []cnt = new int[V + 1];
 
    // Stores the array elements
    for (int i = 0; i < n; ++i)
        a[i] = input[i];
 
    int answer = 0;
 
    // Count the frequencies of the
    // array elements
    for (int i = 0; i < d; ++i)
        cnt[a[i]]++;
 
    // Iterating from d to n-1 index
    // means (d+1)th element to nth element
    for (int i = d; i <= n - 1; ++i) 
    {
 
        // To check the median
        int acc = 0;
 
        int low_median = -1, high_median = -1;
 
        // Iterate over the frequencies
        // of the elements
        for (int v = 0; v <= V; ++v) 
        {
 
            // Add the frequencies
            acc += cnt[v];
 
            // Check if the low_median value is
            // obtained or not, if yes then do
            // not change as it will be minimum
            if (low_median == -1
                && acc >= (int)(Math.floor((d + 1) / 2.0)))
                low_median = v;
 
            // Check if the high_median value is
            // obtained or not, if yes then do not
            // change it as it will be maximum
            if (high_median == -1
                && acc >= (int)(Math.ceil((d + 1) / 2.0)))
                high_median = v;
        }
 
        // Store 2 * median of K trailing elements
        int double_median = low_median + high_median;
 
        // If the current >= 2 * median
        if (a[i] >= double_median)
            answer++;
 
        // Decrease the frequency for (k-1)-th element
        cnt[a[i - d]]--;
 
        // Increase the frequency of the
        // current element
        cnt[a[i]]++;
    }
 
    // Print the count
    System.out.print(answer +"\n");
}
 
// Driver Code
public static void main(String[] args)
{
    int input[] = { 1, 2, 2, 4, 5 };
    int n = input.length;
    int k = 3;
 
    solve(n, k, input);
}
}
 
// This code is contributed by sapnasingh4991
 
  

Python3

   # Python3 program to implement
# the above approach
import math
 
N = 200000
V = 500
 
# Function to find the count of array
# elements >= twice the median of K
# trailing array elements
def solve(n, d, input1):
 
    a = [0] * N
 
    # Stores frequencies
    cnt = [0] * (V + 1)
 
    # Stores the array elements
    for i in range(n):
        a[i] = input1[i]
 
    answer = 0
 
    # Count the frequencies of the
    # array elements
    for i in range(d):
        cnt[a[i]] += 1
 
    # Iterating from d to n-1 index
    # means (d+1)th element to nth element
    for i in range(d, n):
 
        # To check the median
        acc = 0
 
        low_median = -1
        high_median = -1
 
        # Iterate over the frequencies
        # of the elements
        for v in range(V + 1):
 
            # Add the frequencies
            acc += cnt[v]
 
            # Check if the low_median value is
            # obtained or not, if yes then do
            # not change as it will be minimum
            if (low_median == -1 and
                acc >= int(math.floor((d + 1) / 2.0))):
                low_median = v
 
            # Check if the high_median value is
            # obtained or not, if yes then do not
            # change it as it will be maximum
            if (high_median == -1 and
                acc >= int(math.ceil((d + 1) / 2.0))):
                high_median = v
 
        # Store 2 * median of K trailing elements
        double_median = low_median + high_median
 
        # If the current >= 2 * median
        if (a[i] >= double_median):
            answer += 1
 
        # Decrease the frequency for (k-1)-th element
        cnt[a[i - d]] -= 1
 
        # Increase the frequency of the
        # current element
        cnt[a[i]] += 1
 
    # Print the count
    print(answer)
 
# Driver Code
if __name__ == "__main__":
     
    input1 = [ 1, 2, 2, 4, 5 ]
    n = len(input1)
    k = 3
 
    solve(n, k, input1)
 
# This code is contributed by chitranayal
 
  

C#

   // C# Program to implement
// the above approach
using System;
class GFG{
 
static int N = (int) 2e5;
static int V = 500;
 
// Function to find the count of array
// elements >= twice the median of K
// trailing array elements
static void solve(int n, int d, int []input)
{
    int []a = new int[N];
 
    // Stores frequencies
    int []cnt = new int[V + 1];
 
    // Stores the array elements
    for (int i = 0; i < n; ++i)
        a[i] = input[i];
 
    int answer = 0;
 
    // Count the frequencies of the
    // array elements
    for (int i = 0; i < d; ++i)
        cnt[a[i]]++;
 
    // Iterating from d to n-1 index
    // means (d+1)th element to nth element
    for (int i = d; i <= n - 1; ++i) 
    {
 
        // To check the median
        int acc = 0;
 
        int low_median = -1, high_median = -1;
 
        // Iterate over the frequencies
        // of the elements
        for (int v = 0; v <= V; ++v) 
        {
 
            // Add the frequencies
            acc += cnt[v];
 
            // Check if the low_median value is
            // obtained or not, if yes then do
            // not change as it will be minimum
            if (low_median == -1 && 
                acc >= (int)(Math.Floor((d + 1) / 2.0)))
                low_median = v;
 
            // Check if the high_median value is
            // obtained or not, if yes then do not
            // change it as it will be maximum
            if (high_median == -1 && 
                acc >= (int)(Math.Ceiling((d + 1) / 2.0)))
                high_median = v;
        }
 
        // Store 2 * median of K trailing elements
        int double_median = low_median + high_median;
 
        // If the current >= 2 * median
        if (a[i] >= double_median)
            answer++;
 
        // Decrease the frequency for (k-1)-th element
        cnt[a[i - d]]--;
 
        // Increase the frequency of the
        // current element
        cnt[a[i]]++;
    }
 
    // Print the count
    Console.Write(answer + "\n");
}
 
// Driver Code
public static void Main(String[] args)
{
    int []input = { 1, 2, 2, 4, 5 };
    int n = input.Length;
    int k = 3;
 
    solve(n, k, input);
}
}
 
// This code is contributed by sapnasingh4991
 
  

Javascript

   <script>
 
// Javascript Program to implement
// the above approach
const N = 2e5;
const V = 500;
 
// Function to find the count of array
// elements >= twice the median of K
// trailing array elements
function solve(n, d, input)
{
    let a = new Array(N);
 
    // Stores frequencies
    let cnt = new Array(V + 1);
 
    // Stores the array elements
    for(let i = 0; i < n; ++i)
        a[i] = input[i];
 
    let answer = 0;
 
    // Count the frequencies of the
    // array elements
    for(let i = 0; i < d; ++i)
        cnt[a[i]]++;
 
    // Iterating from d to n-1 index
    // means (d+1)th element to nth element
    for(let i = d; i <= n - 1; ++i)
    {
         
        // To check the median
        let acc = 0;
 
        let low_median = -1, high_median = -1;
 
        // Iterate over the frequencies
        // of the elements
        for(let v = 0; v <= V; ++v) 
        {
             
            // Add the frequencies
            acc += cnt[v];
 
            // Check if the low_median value is
            // obtained or not, if yes then do
            // not change as it will be minimum
            if (low_median == -1 && 
                acc >= parseInt(Math.floor((d + 1) / 2.0)))
                low_median = v;
 
            // Check if the high_median value is
            // obtained or not, if yes then do not
            // change it as it will be maximum
            if (high_median == -1 && 
                acc >= parseInt(Math.ceil((d + 1) / 2.0)))
                high_median = v;
        }
 
        // Store 2 * median of K trailing elements
        let double_median = low_median + high_median;
 
        // If the current >= 2 * median
        if (a[i] >= double_median)
            answer++;
 
        // Decrease the frequency for (k-1)-th element
        cnt[a[i - d]]--;
 
        // Increase the frequency of the
        // current element
        cnt[a[i]]++;
    }
 
    // Print the count
    document.write(answer);
}
 
// Driver Code
let input = [ 1, 2, 2, 4, 5 ];
let n = input.length;
let k = 3;
 
solve(n, k, input);
 
// This code is contributed by subham348
 
</script>
 
  

Output

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

Count triplets (i, j, k) in an array of distinct elements such that a[i] a[k] and i < j < k

het30401

Improve

Article Tags :

Practice Tags :

Count of Array elements greater than or equal to twice the Median of K trailing Array elements

C++14

Java

Python

C#

Javascript

C++

C

Java

Python3

C#

Javascript

Similar Reads