Skip to content
Related Articles

Related Articles

Maximum frequencies in each M-length subarray

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 24 Aug, 2021

Given an array arr[] consisting of N integers and a positive integer M, the task is to find the maximum frequency for each M length subarray ( 0 < M ≤ N).

Examples:

Input: arr[] = {1, 2, 3, 1, 2, 4, 1, 4, 4}, M = 4
Output: 2 2 1 2 2 3
Explanation:
All the M length sub-arrays with the maximum frequency of any element are:

  1. {1, 2, 3, 1}, The maximum frequency of an element is 2.
  2. {2, 3, 1, 2}, The maximum frequency of an element is 2.
  3. {3, 1, 2, 4}, The maximum frequency of an element is 1.
  4. {1, 2, 4, 1}, The maximum frequency of an element is 2.
  5. {2, 4, 1, 4}, The maximum frequency of an element is 2.
  6. {4, 1, 4, 4}, The maximum frequency of an element is 3.

Input: arr[] = {1, 1, 2, 2, 3, 5}, M = 4
Output: 2 2 2ing 

Approach: The given problem can be solved by finding the frequencies for each M-sized sub-array print the maximum frequency among all. Follow the steps below to solve the given problem:

  • Initialize an unordered map, say M to stores the frequencies of array elements.
  • Initialize the variable, say val as 0 to store the maximum frequency of an element of the subarray.
  • Iterate over the range [0, N] using the variable i and perform the following steps:
    • If the value of (i – M) is greater than equal to 0, then decrease the value of A[i – M] from the map M.
    • Add the value of arr[i] in the map M.
    • Iterate over the map M and update the value of val as the maximum of val or x.second.
    • Print the value of val as the maximum for the present M-sized subarray.

Below is an implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the frequency of
// the most common element in each M
// length subarrays
void maxFrequencySubarrayUtil(
    vector<int> A, int N, int M)
{
    int i = 0;
 
    // Stores frequency of array element
    unordered_map<int, int> m;
 
    // Stores the maximum frequency
    int val = 0;
 
    // Iterate for the first sub-array
    // and store the maximum
    for (; i < M; i++) {
        m[A[i]]++;
        val = max(val, m[A[i]]);
    }
 
    // Print the maximum frequency for
    // the first subarray
    cout << val << " ";
 
    // Iterate over the range [M, N]
    for (i = M; i < N; i++) {
 
        // Subtract the A[i - M] and
        // add the A[i] in the map
        m[A[i - M]]--;
        m[A[i]]++;
 
        val = 0;
 
        // Find the maximum frequency
        for (auto x : m) {
            val = max(val, x.second);
        }
 
        // Print the maximum frequency
        // for the current subarray
        cout << val << " ";
    }
}
 
// Driver Code
int main()
{
    vector<int> A = { 1, 1, 2, 2, 3, 5 };
    int N = A.size();
    int M = 4;
    maxFrequencySubarrayUtil(A, N, M);
 
    return 0;
}


Java




// Java program for the above approach
 
import java.util.*;
 
class GFG {
 
    // Function to find the frequency of
    // the most common element in each M
    // length subarrays
    static void maxFrequencySubarrayUtil(int[] A, int N, int M) {
        int i = 0;
 
        // Stores frequency of array element
        HashMap<Integer, Integer> m = new HashMap<Integer, Integer>();
 
        // Stores the maximum frequency
        int val = 0;
 
        // Iterate for the first sub-array
        // and store the maximum
        for (; i < M; i++) {
            if (m.containsKey(A[i])) {
                m.put(A[i], m.get(A[i]) + 1);
            } else {
                m.put(A[i], 1);
            }
            val = Math.max(val, m.get(A[i]));
        }
 
        // Print the maximum frequency for
        // the first subarray
        System.out.print(val + " ");
 
        // Iterate over the range [M, N]
        for (i = M; i < N; i++) {
 
            // Subtract the A[i - M] and
            // add the A[i] in the map
            if (m.containsKey(i - M)) {
                m.put(i - M, m.get(i - M) - 1);
            }
            if (m.containsKey(A[i])) {
                m.put(A[i], m.get(A[i]) + 1);
            } else {
                m.put(A[i], 1);
            }
 
            val = 0;
 
            // Find the maximum frequency
            for (Map.Entry<Integer, Integer> x : m.entrySet()) {
                val = Math.max(val, x.getValue());
            }
 
            // Print the maximum frequency
            // for the current subarray
            System.out.print(val + " ");
        }
    }
 
    // Driver Code
    public static void main(String[] args) {
        int[] A = { 1, 1, 2, 2, 3, 5 };
        int N = A.length;
        int M = 4;
        maxFrequencySubarrayUtil(A, N, M);
 
    }
}
 
// This code is contributed by 29AjayKumar


Python3




# Python 3 program for the above approach
 
# Function to find the frequency of
# the most common element in each M
# length subarrays
def maxFrequencySubarrayUtil(A,N,M):
    i = 0
 
    # Stores frequency of array element
    m = {}
 
    # Stores the maximum frequency
    val = 0
 
    # Iterate for the first sub-array
    # and store the maximum
    while(i < M):
        if A[i] in m:
            m[A[i]] += 1
        else:
            m[A[i]] = 1
        val = max(val, m[A[i]])
        i += 1
 
    # Print the maximum frequency for
    # the first subarray
    print(val,end = " ")
 
    # Iterate over the range [M, N]
    for i in range(M,N,1):
        # Subtract the A[i - M] and
        # add the A[i] in the map
        if A[i - M] in m:
            m[A[i - M]] -= 1
        else:
            m[A[i - M]] = 0
        if A[i] in m:
            m[A[i]] += 1
 
        val = 0
 
        # Find the maximum frequency
        for key,value in m.items():
            val = max(val, value)
 
        # Print the maximum frequency
        # for the current subarray
        print(val,end=" ")
 
# Driver Code
if __name__ == '__main__':
    A = [1, 1, 2, 2, 3, 5]
    N = len(A)
    M = 4
    maxFrequencySubarrayUtil(A, N, M)
     
    # This code is contributed by ipg2016107.


C#




using System;
using System.Collections.Generic;
public class GFG {
 
    // Function to find the frequency of
    // the most common element in each M
    // length subarrays
    static void maxFrequencySubarrayUtil(int[] A, int N,
                                         int M)
    {
        int i = 0;
 
        // Stores frequency of array element
        Dictionary<int, int> m = new Dictionary<int, int>();
        // Stores the maximum frequency
        int val = 0;
 
        // Iterate for the first sub-array
        // and store the maximum
        for (; i < M; i++) {
            if (m.ContainsKey(A[i])) {
                val = m[A[i]];
                m.Remove(A[i]);
                m.Add(A[i], val + 1);
            }
            else {
                m.Add(A[i], 1);
            }
            val = Math.Max(val, m[A[i]]);
        }
 
        // Print the maximum frequency for
        // the first subarray
        Console.Write(val + " ");
 
        // Iterate over the range [M, N]
        for (i = M; i < N; i++) {
 
            // Subtract the A[i - M] and
            // add the A[i] in the map
            if (m.ContainsKey(i - M)) {
                val = i - M;
                m.Remove(i - M);
                m.Add(i - M, val - 1);
            }
           if (m.ContainsKey(A[i])) {
                val = m[A[i]];
                m.Remove(A[i]);
                m.Add(A[i], val + 1);
            }
            else {
                m.Add(A[i], 1);
            }
             
            val = Math.Max(val, m[A[i]]);
         
 
        val = 0;
 
        // Find the maximum frequency
        foreach(KeyValuePair<int, int> x in m)
        {
 
            val = Math.Max(val, x.Value);
        }
 
        // Print the maximum frequency
        // for the current subarray
        Console.Write(val + " ");
        }
}
 
// Driver Code
 
static public void Main()
{
    int[] A = { 1, 1, 2, 2, 3, 5 };
    int N = 6;
    int M = 4;
    maxFrequencySubarrayUtil(A, N, M);
}
}
 
// This code is contributed by maddler.


Javascript




<script>
        // JavaScript Program to implement
        // the above approach
 
        // Function to find the frequency of
        // the most common element in each M
        // length subarrays
        function maxFrequencySubarrayUtil(A, N, M)
        {
 
            // Stores frequency of array element
            let m = new Map();
 
            // Stores the maximum frequency
            let val = 0;
 
            // Iterate for the first sub-array
            // and store the maximum
            for (let i = 0; i < M; i++) {
 
                if (m.has(A[i])) {
                    m.set(m.get(A[i]), m.get(A[i]) + 1);
                }
                else {
                    m.set(A[i], 1);
                }
                val = Math.max(val, m.get(A[i]));
            }
 
            // Print the maximum frequency for
            // the first subarray
            document.write(val + " ");
 
            // Iterate over the range [M, N]
            for (i = M; i < N; i++) {
 
                // Subtract the A[i - M] and
                // add the A[i] in the map
                if (m.has(A[i - m]))
                    m.set(m.get(A[i - M]), m.get(A[i - M]) - 1);
                if (m.has(A[i]))
                    m.set(m.get(A[i]), m.get(A[i]) + 1);
 
                val = 0;
 
                // Find the maximum frequency
                for (let [key, value] of m) {
                    val = Math.max(val, value);
                }
 
                // Print the maximum frequency
                // for the current subarray
                document.write(val + " ");
            }
        }
 
        // Driver Code
        let A = [1, 1, 2, 2, 3, 5];
        let N = A.length;
        let M = 4;
        maxFrequencySubarrayUtil(A, N, M);
 
// This code is contributed by Potta Lokesh
    </script>


Output: 

2 2 2

 

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!