# Maximize frequency of an element by at most one increment or decrement of all array elements

• Difficulty Level : Medium
• Last Updated : 27 Apr, 2021

Given an array arr[] of size N, the task is to find the maximum frequency of any array element by incrementing or decrementing each array element by 1 at most once.

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = { 3, 1, 4, 1, 5, 9, 2 }
Output:
Explanation:
Decrementing the value of arr by 1 modifies arr[] to { 2, 1, 4, 1, 5, 9, 2 }
Incrementing the value of arr by 1 modifies arr[] to { 2, 2, 4, 1, 5, 9, 2 }
Incrementing the value of arr by 1 modifies arr[] to { 2, 2, 4, 1, 5, 9, 2 }
Therefore, the frequency of an array element(arr) is 4 which is the maximum possible.

Input: arr[] = { 0, 1, 2, 3, 4, 5, 6 }
Output:
Explanation:
Incrementing the value of arr by 1 modifies arr[] to { 1, 1, 2, 3, 4, 5, 6 }
Decrementing the value of arr by 1 modifies arr[] to { 1, 1, 1, 3, 4, 5, 6 }
Therefore, the frequency of an array element(arr) is 3 which is the maximum possible.

Approach: The problem can be solved using Greedy technique. The idea is to find the largest and the smallest element present in the array and calculate the maximum sum of the frequency of three consecutive numbers by iterating all the numbers over the range of array elements. Finally, print the maximum sum obtained. Follow the steps below to solve the problem:

Below is the implementation of the above approach.

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to maximize the frequency``// of an array element by incrementing or``// decrementing array elements at most once``void` `max_freq(``int` `arr[], ``int` `N)``{` `    ``// Stores the largest array element``    ``int` `Max = *max_element(arr, arr + N);` `    ``// Stores the smallest array element``    ``int` `Min = *min_element(arr, arr + N);` `    ``// freq[i]: Stores frequency of``    ``// (i + Min) in the array``    ``int` `freq[Max - Min + 1] = { 0 };` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Update frequency``        ``// of arr[i]``        ``freq[arr[i] - Min]++;``    ``}` `    ``// Stores maximum frequency of an``    ``// array element by incrementing``    ``// or decrementing array elements``    ``int` `maxSum = 0;` `    ``// Iterate all the numbers over``    ``// the range [Min, Max]``    ``for` `(``int` `i = 0;``         ``i < (Max - Min - 1); i++) {` `        ``// Stores sum of three``        ``// consecutive numbers``        ``int` `val = freq[i] + freq[i + 1] + freq[i + 2];` `        ``// Update maxSum``        ``maxSum = max(maxSum, val);``    ``}` `    ``// Print maxSum``    ``cout << maxSum << ``"\n"``;``}` `// Driver Code``int` `main()``{` `    ``int` `arr[] = { 3, 1, 4, 1, 5, 9, 2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``// Function call``    ``max_freq(arr, N);``    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.Arrays;` `class` `GFG{``    ` `// Function to maximize the frequency``// of an array element by incrementing or``// decrementing array elements at most once``static` `void` `max_freq(``int` `arr[], ``int` `N)``{``    ``Arrays.sort(arr);``    ` `    ``// Stores the largest array element``    ``int` `Max = arr[N - ``1``];` `    ``// Stores the smallest array element``    ``int` `Min = arr[``0``];` `    ``// freq[i]: Stores frequency of``    ``// (i + Min) in the array``    ``int` `freq[] = ``new` `int``[Max - Min + ``1``];` `    ``// Traverse the array``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Update frequency``        ``// of arr[i]``        ``freq[arr[i] - Min]++;``    ``}` `    ``// Stores maximum frequency of an``    ``// array element by incrementing``    ``// or decrementing array elements``    ``int` `maxSum = ``0``;` `    ``// Iterate all the numbers over``    ``// the range [Min, Max]``    ``for``(``int` `i = ``0``; i < (Max - Min - ``1``); i++)``    ``{``        ` `        ``// Stores sum of three``        ``// consecutive numbers``        ``int` `val = freq[i] + freq[i + ``1``] +``                            ``freq[i + ``2``];` `        ``// Update maxSum``        ``maxSum = Math.max(maxSum, val);``    ``}` `    ``// Print maxSum``    ``System.out.println(maxSum);``}` `// Driver Code``public` `static` `void` `main (String[] args)``{``    ``int` `arr[] = { ``3``, ``1``, ``4``, ``1``, ``5``, ``9``, ``2` `};``    ``int` `N = arr.length;``    ` `    ``// Function call``    ``max_freq(arr, N);``}``}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program to implement``# the above approach` `# Function to maximize the frequency``# of an array element by incrementing or``# decrementing array elements at most once``def` `max_freq(arr, N):` `    ``# Stores the largest array element``    ``Max` `=` `max``(arr)` `    ``# Stores the smallest array element``    ``Min` `=` `min``(arr)` `    ``# freq[i]: Stores frequency of``    ``# (i + Min) in the array``    ``freq ``=` `[``0``] ``*` `(``Max` `-` `Min` `+` `1``)` `    ``# Traverse the array``    ``for` `i ``in` `range``(N):` `        ``# Update frequency``        ``# of arr[i]``        ``freq[arr[i] ``-` `Min``] ``+``=` `1` `    ``# Stores maximum frequency of an``    ``# array element by incrementing``    ``# or decrementing array elements``    ``maxSum ``=` `0` `    ``# Iterate all the numbers over``    ``# the range [Min, Max]``    ``for` `i ``in` `range``( ``Max` `-` `Min` `-` `1``):` `        ``# Stores sum of three``        ``# consecutive numbers``        ``val ``=` `freq[i] ``+` `freq[i ``+` `1``] ``+` `freq[i ``+` `2``]` `        ``# Update maxSum``        ``maxSum ``=` `max``(maxSum, val)` `    ``# Print maxSum``    ``print``(maxSum)` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``arr ``=` `[ ``3``, ``1``, ``4``, ``1``, ``5``, ``9``, ``2` `]``    ``N ``=` `len``(arr)` `    ``# Function call``    ``max_freq(arr, N)``    ` `# This code is contributed by AnkThon`

## C#

 `// C# program to implement``// the above approach ``using` `System;`` ` `class` `GFG{``     ` `// Function to maximize the frequency``// of an array element by incrementing or``// decrementing array elements at most once``static` `void` `max_freq(``int``[] arr, ``int` `N)``{``    ``Array.Sort(arr);``     ` `    ``// Stores the largest array element``    ``int` `Max = arr[N - 1];`` ` `    ``// Stores the smallest array element``    ``int` `Min = arr;`` ` `    ``// freq[i]: Stores frequency of``    ``// (i + Min) in the array``    ``int``[] freq = ``new` `int``[Max - Min + 1];`` ` `    ``// Traverse the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``         ` `        ``// Update frequency``        ``// of arr[i]``        ``freq[arr[i] - Min]++;``    ``}`` ` `    ``// Stores maximum frequency of an``    ``// array element by incrementing``    ``// or decrementing array elements``    ``int` `maxSum = 0;`` ` `    ``// Iterate all the numbers over``    ``// the range [Min, Max]``    ``for``(``int` `i = 0; i < (Max - Min - 1); i++)``    ``{``         ` `        ``// Stores sum of three``        ``// consecutive numbers``        ``int` `val = freq[i] + freq[i + 1] +``                            ``freq[i + 2];`` ` `        ``// Update maxSum``        ``maxSum = Math.Max(maxSum, val);``    ``}`` ` `    ``// Print maxSum``    ``Console.WriteLine(maxSum);``}`` ` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[] arr = { 3, 1, 4, 1, 5, 9, 2 };``    ``int` `N = arr.Length;``     ` `    ``// Function call``    ``max_freq(arr, N);``}``}` `// This code is contributed by code_hunt.`

## Javascript

 ``
Output:
`4`

Time Complexity: O(N + |Max – Min|), where Max, Min denotes the largest and the smallest array elements respectively
Auxiliary Space: O(|Max – Min|)

My Personal Notes arrow_drop_up