# Remove array elements to reduce frequency of each array element to at most K

• Last Updated : 08 Jun, 2021

Given a sorted array arr[] of size N and an integer K, the task is to print the array by removing the minimum number of array elements to make frequency of each element at most K.

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[] = { 1, 1, 1, 1, 2, 2, 2, 3, 4, 4, 4, 4, 5 }, K = 3
Output: { 1, 1, 1, 2, 2, 2, 3, 4, 4, 4, 5 }
Explanation:
Removing arr, arr modifies arr[] to { 1, 1, 1, 2, 2, 2, 3, 4, 4, 4, 5 }.
The frequency of each distinct array element is at most K(=3).
Therefore, the required output is { 1, 1, 1, 2, 2, 2, 3, 4, 4, 4, 5 }.

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

Naive Approach: The simplest approach to solve this problem is to traverse the array and check if the frequency of the array elements is greater than K or not. If found to be true, then remove the current element from the array. Otherwise, increment the frequency of the array element and print the array element.

Time Complexity: O(N2)
Auxiliary Space: O(1)

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

• Initialize a variable, say j = 0 to store the index of any array element by removing the array elements such that the frequency of each distinct element is at most K.
• Traverse the array and check if j < K or arr[i] > arr[j – K] is true or not. If found to be true, then update arr[j++] = arr[i].
• Finally, print the array by removing all the array elements whose index is greater than or equal to j.

Below is the implementation of the above approach.

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to remove array elements``// such that frequency of each distinct``// array element is at most K``vector<``int``> RemoveElemArr(vector<``int``>& arr,``                        ``int` `n, ``int` `k)``{``    ``// Base Case``    ``if` `(n == 0 || n == 1)``        ``return` `arr;` `    ``// Stores index of array element by removing``    ``// the array element such that the frequency``    ``// of array elements is at most K``    ``int` `j = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// If j < k or arr[i] > arr[j - k]``        ``if` `(j < k || arr[i] > arr[j - k]) {` `            ``// Update arr[j]``            ``arr[j++] = arr[i];``        ``}``    ``}` `    ``// Remove array elements``    ``while` `(arr.size() > j) {``        ``arr.pop_back();``    ``}` `    ``return` `arr;``}` `// Function to print the array``void` `printArray(vector<``int``>& arr)``{` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < arr.size();``        ``i++) {``        ``cout << arr[i] << ``" "``;``    ``}``}` `// Utility Function to remove array elements``// such that frequency of each distinct``// array element is at most K``void` `UtilRemov(vector<``int``>& arr, ``int` `n, ``int` `k)``{``    ``arr = RemoveElemArr(arr, n, k);` `    ``// Print updated array``    ``printArray(arr);``}` `// Driver Code``int` `main()``{` `    ``vector<``int``> arr``        ``= { 1, 2, 2, 3, 4, 4, 4, 5, 5 };` `    ``int` `k = 2;``    ``int` `n = arr.size();` `    ``UtilRemov(arr, n, k);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG``{` `// Function to remove array elements``// such that frequency of each distinct``// array element is at most K``static` `int` `[] RemoveElemArr(``int` `[]arr,``                        ``int` `n, ``int` `k)``{``  ` `    ``// Base Case``    ``if` `(n == ``0` `|| n == ``1``)``        ``return` `arr;` `    ``// Stores index of array element by removing``    ``// the array element such that the frequency``    ``// of array elements is at most K``    ``int` `j = ``0``;` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{` `        ``// If j < k or arr[i] > arr[j - k]``        ``if` `(j < k || arr[i] > arr[j - k])``        ``{` `            ``// Update arr[j]``            ``arr[j++] = arr[i];``        ``}``    ``}` `    ``// Remove array elements``    ``while` `(arr.length > j)``    ``{``        ``arr = Arrays.copyOfRange(arr, ``0``, arr.length-``1``);``    ``}` `    ``return` `arr;``}` `// Function to print the array``static` `void` `printArray(``int` `[] arr)``{` `    ``// Traverse the array``    ``for` `(``int` `i = ``0``; i < arr.length;``        ``i++)``    ``{``        ``System.out.print(arr[i]+ ``" "``);``    ``}``}` `// Utility Function to remove array elements``// such that frequency of each distinct``// array element is at most K``static` `void` `UtilRemov(``int` `[]arr, ``int` `n, ``int` `k)``{``    ``arr = RemoveElemArr(arr, n, k);` `    ``// Print updated array``    ``printArray(arr);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{` `    ``int` `[]arr``        ``= { ``1``, ``2``, ``2``, ``3``, ``4``, ``4``, ``4``, ``5``, ``5` `};``    ``int` `k = ``2``;``    ``int` `n = arr.length;``    ``UtilRemov(arr, n, k);``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach` `# Function to remove array elements``# such that frequency of each distinct``# array element is at most K``def` `RemoveElemArr(arr, n, k):``    ` `    ``# Base Case``    ``if` `(n ``=``=` `0` `or` `n ``=``=` `1``):``        ``return` `arr` `    ``# Stores index of array element by``    ``# removing the array element such``    ``# that the frequency of array``    ``# elements is at most K``    ``j ``=` `0` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):``        ` `        ``# If j < k or arr[i] > arr[j - k]``        ``if` `(j < k ``or` `arr[i] > arr[j ``-` `k]):``            ` `            ``# Update arr[j]``            ``arr[j], j ``=` `arr[i], j ``+` `1``            ` `    ``# Remove array elements``    ``while` `(``len``(arr) > j):``        ``del` `arr[``-``1``]` `    ``return` `arr` `# Function to print the array``def` `printArray(arr):``    ` `    ``# Traverse the array``    ``for` `i ``in` `arr:``        ``print``(i, end ``=` `" "``)``        ` `# Utility Function to remove array elements``# such that frequency of each distinct``# array element is at most K``def` `UtilRemov(arr, n, k):``    ` `    ``arr ``=` `RemoveElemArr(arr, n, k)` `    ``# Print updated array``    ``printArray(arr)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``arr ``=` `[ ``1``, ``2``, ``2``, ``3``, ``4``, ``4``, ``4``, ``5``, ``5` `]` `    ``k ``=` `2``    ``n ``=` `len``(arr)` `    ``UtilRemov(arr, n, k)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program to implement``// the above approach ``using` `System;``using` `System.Linq;` `class` `GFG``{` `  ``// Function to remove array elements``  ``// such that frequency of each distinct``  ``// array element is at most K``  ``static` `int` `[] RemoveElemArr(``int` `[]arr,``                              ``int` `n, ``int` `k)``  ``{` `    ``// Base Case``    ``if` `(n == 0 || n == 1)``      ``return` `arr;` `    ``// Stores index of array element by removing``    ``// the array element such that the frequency``    ``// of array elements is at most K``    ``int` `j = 0;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++)``    ``{` `      ``// If j < k or arr[i] > arr[j - k]``      ``if` `(j < k || arr[i] > arr[j - k])``      ``{` `        ``// Update arr[j]``        ``arr[j++] = arr[i];``      ``}``    ``}` `    ``// Remove array elements``    ``while` `(arr.Length > j)``    ``{``      ``arr = arr.Take(arr.Length - 1).ToArray();``    ``}` `    ``return` `arr;``  ``}` `  ``// Function to print the array``  ``static` `void` `printArray(``int` `[] arr)``  ``{` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < arr.Length;``         ``i++)``    ``{``      ``Console.Write(arr[i] + ``" "``);``    ``}``  ``}` `  ``// Utility Function to remove array elements``  ``// such that frequency of each distinct``  ``// array element is at most K``  ``static` `void` `UtilRemov(``int` `[]arr, ``int` `n, ``int` `k)``  ``{``    ``arr = RemoveElemArr(arr, n, k);` `    ``// Print updated array``    ``printArray(arr);``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main()``  ``{``    ``int` `[]arr``      ``= { 1, 2, 2, 3, 4, 4, 4, 5, 5 };``    ``int` `k = 2;``    ``int` `n = arr.Length;``    ``UtilRemov(arr, n, k);``  ``}``}` `// This code is contributed by sanjoy_62.`

## Javascript

 ``
Output:
`1 2 2 3 4 4 5 5`

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

My Personal Notes arrow_drop_up