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 = 2
Output: {1, 2, 2, 3}
Explanation:
Remove 2 once, as it occurs more than 2 times.
Input: arr[] = {3, 3, 3}, K = 1
Output: {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++ 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 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 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# 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 |
<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> |
{1, 1, 2, 2, 3, 3, 4, 5, }
Time complexity: O(N)
Auxiliary Space: O(N), where N is the size of the given array.
Efficient Approach:-
- As the array is sorted so the same type of elements are present adjacent to each other
- We will simply traverse the array and only print a element at most K times
Implementation:-
// 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)
{ // count of current element
int c = 0;
// current element
int curr = arr[0];
// Iterate over the array
for ( int i = 0; i < n; i++) {
// if same element increase count
if (arr[i] == curr)
c++;
// else make count 1 and change current element
else {
c = 1;
curr = arr[i];
}
// if count is less than K print the element
if (c <= K)
cout << arr[i] << " " ;
}
} // 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;
} // This code is contributed by shubhamrajput6156 |
// Java program to reduce the array // such that each element appears // at most K times import java.util.Scanner;
class Main {
// Function to reduce the array
public static void reduceArray( int arr[], int n, int K)
{
// count of current element
int c = 0 ;
// current element
int curr = arr[ 0 ];
// Iterate over the array
for ( int i = 0 ; i < n; i++)
{
// if same element increase count
if (arr[i] == curr)
c++;
// else make count 1 and change current element
else {
c = 1 ;
curr = arr[i];
}
// if count is less than K print the element
if (c <= K)
System.out.print(arr[i] + " " );
}
}
// 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);
}
} |
# Python program to reduce the array # such that each element appears # at most K times # Function to reduce the array def reduce_array(arr, n, K):
# count of current element
c = 0
# current element
curr = arr[ 0 ]
for i in range (n):
# if same element increase count
if arr[i] = = curr:
c + = 1
# else make count 1 and change current element
else :
c = 1
curr = arr[i]
# if count is less than K print the element
if c < = K:
print (arr[i], end = ' ' )
# driver code arr = [ 1 , 1 , 1 , 2 , 2 , 2 , 3 , 3 , 3 , 3 , 3 , 3 , 4 , 5 ]
n = len (arr)
K = 2
reduce_array(arr, n, K) # This code is contributed by redmoonz. |
// C# program to reduce the array // such that each element appears // at most K times using System;
public static class Globals
{ // Function to reduce the array
public static void reduceArray( int [] arr, int n, int K)
{
// count of current element
int c = 0;
// current element
int curr = arr[0];
// Iterate over the array
for ( int i = 0; i < n; i++)
{
// if same element increase count
if (arr[i] == curr)
c++;
// else make count 1 and change current element
else {
c = 1;
curr = arr[i];
}
// if count is less than K print the element
if (c <= K)
{
Console.Write( " " );
Console.Write(arr[i]);
}
}
}
// Driver Code
internal static void Main()
{
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 bhardwajji |
// Function to reduce the array function reduceArray(arr, n, K) {
// count of current element
let c = 0;
// current element
let curr = arr[0];
let output = "" ;
// Iterate over the array
for (let i = 0; i < n; i++) {
// if same element increase count
if (arr[i] === curr)
c++;
// else make count 1 and change current element
else {
c = 1;
curr = arr[i];
}
// if count is less than K print the element
if (c <= K)
output += arr[i] + " " ;
}
console.log(output);
} // Driver code const arr = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 5]; const n = arr.length; const K = 2; // Function call reduceArray(arr, n, K); |
1 1 2 2 3 3 4 5
Time Complexity:- O(N)
Auxiliary Space:- O(1)