Reduce the array such that each element appears at most K times
Last Updated :
24 Feb, 2023
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++
#include <bits/stdc++.h>
using namespace std;
void reduceArray( int arr[], int n, int K)
{
vector< int > vec;
int size = 0;
int curr_ele = arr[0], curr_freq = 1;
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++;
}
cout << "{" ;
for ( int i = 0; i < size; i++) {
cout << vec[i] << ", " ;
}
cout << "}" ;
}
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;
reduceArray(arr, n, K);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void reduceArray( int arr[], int n, int K)
{
Vector<Integer> vec = new Vector<Integer>();
int size = 0 ;
int curr_ele = arr[ 0 ], curr_freq = 1 ;
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++;
}
System.out.print( "{" );
for ( int i = 0 ; i < size; i++) {
System.out.print(vec.get(i)+ ", " );
}
System.out.print( "}" );
}
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 ;
reduceArray(arr, n, K);
}
}
|
Python3
def reduceArray(arr, n, K) :
vec = [];
size = 0 ;
curr_ele = arr[ 0 ]; curr_freq = 1 ;
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 ( "{" ,end = "");
for i in range (size) :
print (vec[i] ,end = ", " );
print ( "}" ,end = "");
if __name__ = = "__main__" :
arr = [ 1 , 1 , 1 , 2 ,
2 , 2 , 3 , 3 ,
3 , 3 , 3 , 3 ,
4 , 5 ];
n = len (arr)
K = 2 ;
reduceArray(arr, n, K);
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void reduceArray( int []arr, int n, int K)
{
List< int > vec = new List< int >();
int size = 0;
int curr_ele = arr[0], curr_freq = 1;
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++;
}
Console.Write( "{" );
for ( int i = 0; i < size; i++) {
Console.Write(vec[i]+ ", " );
}
Console.Write( "}" );
}
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;
reduceArray(arr, n, K);
}
}
|
Javascript
<script>
function reduceArray( arr, n, K)
{
var vec=[];
var size = 0;
var curr_ele = arr[0], curr_freq = 1;
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++;
}
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;
reduceArray(arr, n, K);
</script>
|
Output
{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++
#include <bits/stdc++.h>
using namespace std;
void reduceArray( int arr[], int n, int K)
{
int c = 0;
int curr = arr[0];
for ( int i = 0; i < n; i++) {
if (arr[i] == curr)
c++;
else {
c = 1;
curr = arr[i];
}
if (c <= K)
cout << arr[i] << " " ;
}
}
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;
reduceArray(arr, n, K);
return 0;
}
|
Java
import java.util.Scanner;
class Main {
public static void reduceArray( int arr[], int n, int K)
{
int c = 0 ;
int curr = arr[ 0 ];
for ( int i = 0 ; i < n; i++)
{
if (arr[i] == curr)
c++;
else {
c = 1 ;
curr = arr[i];
}
if (c <= K)
System.out.print(arr[i] + " " );
}
}
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 ;
reduceArray(arr, n, K);
}
}
|
Python3
def reduce_array(arr, n, K):
c = 0
curr = arr[ 0 ]
for i in range (n):
if arr[i] = = curr:
c + = 1
else :
c = 1
curr = arr[i]
if c < = K:
print (arr[i], end = ' ' )
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)
|
C#
using System;
public static class Globals
{
public static void reduceArray( int [] arr, int n, int K)
{
int c = 0;
int curr = arr[0];
for ( int i = 0; i < n; i++)
{
if (arr[i] == curr)
c++;
else {
c = 1;
curr = arr[i];
}
if (c <= K)
{
Console.Write( " " );
Console.Write(arr[i]);
}
}
}
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;
reduceArray(arr, n, K);
}
}
|
Javascript
function reduceArray(arr, n, K) {
let c = 0;
let curr = arr[0];
let output = "" ;
for (let i = 0; i < n; i++) {
if (arr[i] === curr)
c++;
else {
c = 1;
curr = arr[i];
}
if (c <= K)
output += arr[i] + " " ;
}
console.log(output);
}
const arr = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 5];
const n = arr.length;
const K = 2;
reduceArray(arr, n, K);
|
Time Complexity:- O(N)
Auxiliary Space:- O(1)
Share your thoughts in the comments
Please Login to comment...