# Maximum frequencies in each M-length subarray

• 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 ` `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 m = ``new` `HashMap();`   `        ``// 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 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

 ``

Output:

`2 2 2`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :