Reduce the array such that each element appears at most 2 times

Last Updated : 08 Jun, 2021

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

Examples:

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

Approach: This can be solved with the help of two pointer algorithm.

Start traversing the array from the left and keep two pointers.
One pointer (let’s say i) is used to iterate the array.
And the second pointer (let’s say st) moves forward to find the next unique element. The element in i appears more than twice.

Below is the implementation of the above approach:

CPP

// C++ program to reduce the array
// such that each element appears
// at most 2 times
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to remove duplicates
void removeDuplicates(int arr[], int n)
{
    // Initialise 2nd pointer
    int st = 0;
 
    // Iterate over the array
    for (int i = 0; i < n; i++) {
 
        if (i < n - 2
            && arr[i] == arr[i + 1]
            && arr[i] == arr[i + 2])
            continue;
 
        // Updating the 2nd pointer
        else {
            arr[st] = arr[i];
            st++;
        }
    }
 
    cout << "{";
    for (int i = 0; i < st; i++) {
        cout << arr[i];
 
        if (i != st - 1)
            cout << ", ";
    }
    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]);
 
    // Function call
    removeDuplicates(arr, n);
 
    return 0;
}

Java

// Java program to reduce the array
// such that each element appears
// at most 2 times
class GFG
{
 
// Function to remove duplicates
static void removeDuplicates(int arr[], int n)
{
    // Initialise 2nd pointer
    int st = 0;
 
    // Iterate over the array
    for (int i = 0; i < n; i++) {
 
        if (i < n - 2
            && arr[i] == arr[i + 1]
            && arr[i] == arr[i + 2])
            continue;
 
        // Updating the 2nd pointer
        else {
            arr[st] = arr[i];
            st++;
        }
    }
 
    System.out.print("{");
    for (int i = 0; i < st; i++) {
        System.out.print(arr[i]);
 
        if (i != st - 1)
            System.out.print(", ");
    }
    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;
 
    // Function call
    removeDuplicates(arr, n);
}
}
 
// This code is contributed by sapnasingh4991

Python3

# Python3 program to reduce the array
# such that each element appears
# at most 2 times
 
# Function to remove duplicates
def removeDuplicates(arr, n) :
 
    # Initialise 2nd pointer
    st = 0;
 
    # Iterate over the array
    for i in range(n) :
 
        if (i < n - 2 and arr[i] == arr[i + 1]
            and arr[i] == arr[i + 2]) :
            continue;
 
        # Updating the 2nd pointer
        else :
            arr[st] = arr[i];
            st += 1;
 
    print("{",end="")
    for i in range(st) :
        print(arr[i],end="");
         
        if (i != st - 1) :
            print(", ",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);
     
    # Function call
    removeDuplicates(arr, n);
 
# This code is contributed by Yash_R

C#

// C# program to reduce the array
// such that each element appears
// at most 2 times
using System;
 
class GFG
{
  
// Function to remove duplicates
static void removeDuplicates(int []arr, int n)
{
    // Initialise 2nd pointer
    int st = 0;
  
    // Iterate over the array
    for (int i = 0; i < n; i++) {
  
        if (i < n - 2
            && arr[i] == arr[i + 1]
            && arr[i] == arr[i + 2])
            continue;
  
        // Updating the 2nd pointer
        else {
            arr[st] = arr[i];
            st++;
        }
    }
  
    Console.Write("{");
    for (int i = 0; i < st; i++) {
        Console.Write(arr[i]);
  
        if (i != st - 1)
            Console.Write(", ");
    }
    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;
  
    // Function call
    removeDuplicates(arr, n);
}
}
 
// This code is contributed by sapnasingh4991

Javascript

<script>
// Java program to reduce the array
// such that each element appears
// at most 2 times
 
 
// Function to remove duplicates
function removeDuplicates(arr,n)
{
    // Initialise 2nd pointer
    let st = 0;
 
    // Iterate over the array
    for (let i = 0; i < n; i++) {
 
        if (i < n - 2
            && arr[i] == arr[i + 1]
            && arr[i] == arr[i + 2])
            continue;
 
        // Updating the 2nd pointer
        else {
            arr[st] = arr[i];
            st++;
        }
    }
 
    document.write("{");
    for (let i = 0; i < st; i++) {
        document.write(arr[i]);
 
        if (i != st - 1)
            document.write(", ");
    }
    document.write("}");
}
 
// Driver code
let arr = [ 1, 1, 1, 2,
            2, 2, 3, 3,
            3, 3, 3, 3,
            4, 5 ];
 
let n = arr.length;
 
// Function call
removeDuplicates(arr, n);
 
 
// This code is contributed by sravan kumar
</script>

Output

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

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

Another Approach : Using Counter() function

Calculate the frequency of all elements using a counter function.
Take an empty list.
Traverse the array.
If the frequency of any element is greater than or equal to 2, make its frequency 1 and append it to the list.
If the frequency of any element is equal to 1, take its frequency 0 and append it to the list.
Print the list.

Below is the implementation of the above approach:

Python3

# Python3 program to reduce the array
# such that each element appears
# at most 2 times
from collections import Counter
 
# Function to remove duplicates
def removeDuplicates(arr, n):
    freq = Counter(arr)
     
    # Taking empty list
    l = []
    for i in range(n):
       
        if(freq[arr[i]] >= 2):
           
            # Making frequency to 1
            freq[arr[i]] = 1
            l.append(arr[i])
             
        elif(freq[arr[i]] == 1):
             
            # Making frequency to 0
            # and appending to list
            l.append(arr[i])
            freq[arr[i]] = 0
             
    # Printing the list
    for i in l:
        print(i, end=" ")
 
 
# Driver code
if __name__ == "__main__":
 
    arr = [1, 1, 1, 2,
           2, 2, 3, 3,
           3, 3, 3, 3,
           4, 5]
 
    n = len(arr)
 
    # Function call
    removeDuplicates(arr, n)
 
# This code is contributed by vikkycirus

Output

1 1 2 2 3 3 4 5

Time complexity: O(N)

Space Complexity: O(N)

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.

My Personal Notes