# Reduce the array such that each element appears at most K times

Given a sorted array **arr** of size **N**, the task is to reduce the array such that each element can appear at most K times.**Examples:**

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

Remove 2 once, as it occurs more than 2 times.Input:arr[] = {3, 3, 3}, K = 1Output:{3}Explanation:

Remove 3 twice, as it occurs more than 1 times.

**Approach:**

- Traverse the given array
**arr** - Maintain the count of each unique element in the array while traversing, using a pointer
**i** - If the current frequency of arr[i] till index i is less than or equal to K, add the element arr[i] to the new reduced array and increment the frequency by 1.
- If the current frequency of arr[i] till index i is more than K, skip till you find the next unique element.
- After the traversal ends, print the reduced array.

Below is the implementation of the above approach:

## C++

`// C++ program to reduce the array` `// such that each element appears` `// at most K times` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to reduce the array` `void` `reduceArray(` `int` `arr[], ` `int` `n, ` `int` `K)` `{` ` ` `// Vector to store the reduced array` ` ` `vector<` `int` `> vec;` ` ` `int` `size = 0;` ` ` `int` `curr_ele = arr[0], curr_freq = 1;` ` ` `// Iterate over the array` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` `if` `(curr_ele == arr[i]` ` ` `&& curr_freq <= K) {` ` ` `vec.push_back(arr[i]);` ` ` `size++;` ` ` `}` ` ` `else` `if` `(curr_ele != arr[i]) {` ` ` `curr_ele = arr[i];` ` ` `vec.push_back(arr[i]);` ` ` `size++;` ` ` `curr_freq = 1;` ` ` `}` ` ` `curr_freq++;` ` ` `}` ` ` `// Print the reduced array` ` ` `cout << ` `"{"` `;` ` ` `for` `(` `int` `i = 0; i < size; i++) {` ` ` `cout << vec[i] << ` `", "` `;` ` ` `}` ` ` `cout << ` `"}"` `;` `}` `// Driver code` `int` `main()` `{` ` ` `int` `arr[]` ` ` `= { 1, 1, 1, 2,` ` ` `2, 2, 3, 3,` ` ` `3, 3, 3, 3,` ` ` `4, 5 };` ` ` `int` `n = ` `sizeof` `(arr)` ` ` `/ ` `sizeof` `(arr[0]);` ` ` `int` `K = 2;` ` ` `// Function call` ` ` `reduceArray(arr, n, K);` ` ` `return` `0;` `}` |

## Java

`// Java program to reduce the array` `// such that each element appears` `// at most K times` `import` `java.util.*;` `class` `GFG{` ` ` `// Function to reduce the array` `static` `void` `reduceArray(` `int` `arr[], ` `int` `n, ` `int` `K)` `{` ` ` `// Vector to store the reduced array` ` ` `Vector<Integer> vec = ` `new` `Vector<Integer>();` ` ` `int` `size = ` `0` `;` ` ` `int` `curr_ele = arr[` `0` `], curr_freq = ` `1` `;` ` ` ` ` `// Iterate over the array` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++) {` ` ` ` ` `if` `(curr_ele == arr[i]` ` ` `&& curr_freq <= K) {` ` ` `vec.add(arr[i]);` ` ` `size++;` ` ` `}` ` ` `else` `if` `(curr_ele != arr[i]) {` ` ` `curr_ele = arr[i];` ` ` `vec.add(arr[i]);` ` ` `size++;` ` ` `curr_freq = ` `1` `;` ` ` `}` ` ` `curr_freq++;` ` ` `}` ` ` ` ` `// Print the reduced array` ` ` `System.out.print(` `"{"` `);` ` ` `for` `(` `int` `i = ` `0` `; i < size; i++) {` ` ` `System.out.print(vec.get(i)+ ` `", "` `);` ` ` `}` ` ` `System.out.print(` `"}"` `);` `}` ` ` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[]` ` ` `= { ` `1` `, ` `1` `, ` `1` `, ` `2` `,` ` ` `2` `, ` `2` `, ` `3` `, ` `3` `,` ` ` `3` `, ` `3` `, ` `3` `, ` `3` `,` ` ` `4` `, ` `5` `};` ` ` ` ` `int` `n = arr.length;` ` ` `int` `K = ` `2` `;` ` ` ` ` `// Function call` ` ` `reduceArray(arr, n, K);` ` ` `}` `}` `// This code is contributed by PrinciRaj1992` |

## Python3

`# Python3 program to reduce the array` `# such that each element appears` `# at most K times` `# Function to reduce the array` `def` `reduceArray(arr, n, K) :` ` ` `# List to store the reduced array` ` ` `vec ` `=` `[];` ` ` `size ` `=` `0` `;` ` ` `curr_ele ` `=` `arr[` `0` `]; curr_freq ` `=` `1` `;` ` ` `# Iterate over the array` ` ` `for` `i ` `in` `range` `(n) :` ` ` `if` `(curr_ele ` `=` `=` `arr[i]` ` ` `and` `curr_freq <` `=` `K) :` ` ` `vec.append(arr[i]);` ` ` `size ` `+` `=` `1` `;` ` ` `elif` `(curr_ele !` `=` `arr[i]) :` ` ` `curr_ele ` `=` `arr[i];` ` ` `vec.append(arr[i]);` ` ` `size ` `+` `=` `1` `;` ` ` `curr_freq ` `=` `1` `;` ` ` ` ` `curr_freq ` `+` `=` `1` `;` ` ` `# Print the reduced array` ` ` `print` `(` `"{"` `,end` `=` `"");` ` ` `for` `i ` `in` `range` `(size) :` ` ` `print` `(vec[i] ,end` `=` `", "` `);` ` ` ` ` `print` `(` `"}"` `,end` `=` `"");` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `arr ` `=` `[ ` `1` `, ` `1` `, ` `1` `, ` `2` `,` ` ` `2` `, ` `2` `, ` `3` `, ` `3` `,` ` ` `3` `, ` `3` `, ` `3` `, ` `3` `,` ` ` `4` `, ` `5` `];` ` ` `n ` `=` `len` `(arr)` ` ` `K ` `=` `2` `;` ` ` `# Function call` ` ` `reduceArray(arr, n, K);` `# This code is contributed by AnkitRai01` |

## C#

`// C# program to reduce the array` `// such that each element appears` `// at most K times` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` ` ` `// Function to reduce the array` `static` `void` `reduceArray(` `int` `[]arr, ` `int` `n, ` `int` `K)` `{` ` ` `// List to store the reduced array` ` ` `List<` `int` `> vec = ` `new` `List<` `int` `>();` ` ` `int` `size = 0;` ` ` `int` `curr_ele = arr[0], curr_freq = 1;` ` ` ` ` `// Iterate over the array` ` ` `for` `(` `int` `i = 0; i < n; i++) {` ` ` ` ` `if` `(curr_ele == arr[i]` ` ` `&& curr_freq <= K) {` ` ` `vec.Add(arr[i]);` ` ` `size++;` ` ` `}` ` ` `else` `if` `(curr_ele != arr[i]) {` ` ` `curr_ele = arr[i];` ` ` `vec.Add(arr[i]);` ` ` `size++;` ` ` `curr_freq = 1;` ` ` `}` ` ` `curr_freq++;` ` ` `}` ` ` ` ` `// Print the reduced array` ` ` `Console.Write(` `"{"` `);` ` ` `for` `(` `int` `i = 0; i < size; i++) {` ` ` `Console.Write(vec[i]+ ` `", "` `);` ` ` `}` ` ` `Console.Write(` `"}"` `);` `}` ` ` `// Driver code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `[]arr` ` ` `= { 1, 1, 1, 2,` ` ` `2, 2, 3, 3,` ` ` `3, 3, 3, 3,` ` ` `4, 5 };` ` ` ` ` `int` `n = arr.Length;` ` ` `int` `K = 2;` ` ` ` ` `// Function call` ` ` `reduceArray(arr, n, K);` `}` `}` `// This code is contributed by Princi Singh` |

## Javascript

`<script>` `// JavaScript program to reduce the array` `// such that each element appears` `// at most K times` `// Function to reduce the array` `function` `reduceArray( arr, n, K)` `{` ` ` `// Vector to store the reduced array` ` ` `var` `vec=[];` ` ` `var` `size = 0;` ` ` `var` `curr_ele = arr[0], curr_freq = 1;` ` ` `// Iterate over the array` ` ` `for` `(` `var` `i = 0; i < n; i++) {` ` ` `if` `(curr_ele == arr[i]` ` ` `&& curr_freq <= K) {` ` ` `vec.push(arr[i]);` ` ` `size++;` ` ` `}` ` ` `else` `if` `(curr_ele != arr[i]) {` ` ` `curr_ele = arr[i];` ` ` `vec.push(arr[i]);` ` ` `size++;` ` ` `curr_freq = 1;` ` ` `}` ` ` `curr_freq++;` ` ` `}` ` ` `// Print the reduced array` ` ` `document.write( ` `"{"` `);` ` ` `for` `(` `var` `i = 0; i < size; i++) {` ` ` `document.write( vec[i] +` `", "` `);` ` ` `}` ` ` `document.write(` `"}"` `);` `}` `var` `arr` ` ` `= [ 1, 1, 1, 2,` ` ` `2, 2, 3, 3,` ` ` `3, 3, 3, 3,` ` ` `4, 5 ];` ` ` `var` `n = 14;` ` ` `var` `K = 2;` ` ` `// Function call` ` ` `reduceArray(arr, n, K);` `</script>` |

**Output:**

{1, 1, 2, 2, 3, 3, 4, 5, }

**Time complexity:** O(N) **Space complexity:** O(1)

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**.