Skip to content
Related Articles

Related Articles

Divide array in two maximum equal length arrays of similar and dissimilar elements
  • Last Updated : 16 Sep, 2020

Given an array arr of natural numbers up to n, find the maximum size for which array arr can be divided into two equal-sized arrays, such that the first array contains all same elements while the second array contains all distinct elements.
Examples: 

Input :n = 8, arr[] ={7, 3, 7, 1, 7, 7} 
Output : 
Maximum size is : 3 
arr1[] ={7, 7, 7} 
arr2[] ={1, 3, 7} 
Explanation : 
It is possible to construct two arrays of size 3. 
The first array is [7, 7, 7] and the second array is [1, 3, 7].

Input : n = 7, arr[] ={1, 2, 1, 5, 1, 6, 7, 2} 
Output : 
Maximum size is : 3 
arr1[] ={1, 1, 1} 
arr2[] ={2, 5, 6}

Approach: 
To solve the problem mentioned above the main idea is to use hashing to find the frequency of every element present in the array.

  • Find the element with maximum frequency present in the array arr[] using hash vector v.
  • Find the total unique elements present in array arr[].
  • There are two cases for the element with maximum frequency: the maximum frequency element will go to the first array then the sizes of the array are at most diff1 – 1 and max1 correspondingly. Otherwise, at least one element of maximum frequency goes to the second array and the sizes are at most diff1 and max1 ? 1 correspondingly. Then find the max-size to which array can be splitted as max(min(diff1 ? 1, max1), min(diff1, max1 ? 1)).
  • Find the first array of similar elements using max_size and element with maximum frequency max1.
  • Find the second array of unique elements using max_size and hash vector v.

Below is the implementation of the above approach:



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find the max-size to which
// an array can be divided into 2 equal parts
// such that one part contains unique elements 
// while another contains similar elements
#include <bits/stdc++.h>
using namespace std;
  
// Function to find the max-size to which an array
// can be divided into 2 equal parts
void Solve(int arr[], int size, int n)
{
  
    vector<int> v(n + 1);
  
    // Vector to find the frequency of
    // each element of array
    for (int i = 0; i < size; i++)
        v[arr[i]]++;
  
    // Find the maximum frequency
    // element present in array arr[]
    int max1 = (max_element(v.begin(), v.end()) 
                                       - v.begin());
    // Find total unique elements
    // present in array arr[]
    int diff1 = n + 1 - count(v.begin(), v.end(), 0);
  
    // Find the Max-Size to which
    // an array arr[] can be splitted
    int max_size = max(min(v[max1] - 1, diff1), 
                            min(v[max1], diff1 - 1));
  
    cout << "Maximum size is :" << max_size << "\n";
  
    // Find the first array
    // containing same elements
    cout << "The First Array Is : \n";
    for (int i = 0; i < max_size; i++) {
        cout << max1 << " ";
        v[max1] -= 1;
    }
  
    cout << "\n";
  
    // Find the second array
    // containing unique elements
    cout << "The Second Array Is : \n";
    for (int i = 0; i < (n + 1); i++) {
        if (v[i] > 0) {
            cout << i << " ";
            max_size--;
        }
        if (max_size < 1)
            break;
    }
  
    cout << "\n";
}
  
// Driver code
int main()
{
    // initialise n
    int n = 7;
  
    // array declaration
    int arr[] = { 1, 2, 1, 5, 1, 6, 7, 2 };
  
    // size of array
    int size = sizeof(arr) / sizeof(arr[0]);
  
    Solve(arr, size, n);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find the 
// max-size to which an array 
// can be divided into 2 equal parts
// such that one part contains unique 
// elements while another contains 
// similar elements
import java.io.*;
import java.lang.*;
import java.util.*;
class GFG{
    
  // Function to find the max-size to 
  // which an array can be divided into 
  // 2 equal parts
  static void Solve(int arr[], 
                    int size, int n)
  {
    int[] v = new int[n + 1];
  
    // Array to find the frequency of
    // each element of array
    for (int i = 0; i < size; i++)
      v[arr[i]]++;
  
    // Find the index maximum frequency
    // element present in array arr[]
    int max1 = -1, mx = -1;
    for (int i = 0; i < v.length; i++) 
    {
      if (v[i] > mx) 
      {
        mx = v[i];
        max1 = i;
      }
    }
    // Find total unique elements
    // present in array arr[]
    int cnt = 0;
    for (int i : v) 
    {
      if (i == 0)
        ++cnt;
    }
    int diff1 = n + 1 - cnt;
  
    // Find the Max-Size to which
    // an array arr[] can be splitted
    int max_size = Math.max(Math.min(v[max1] - 1
                                     diff1),
                            Math.min(v[max1], 
                                     diff1 - 1));
    System.out.println("Maximum size is: "
                        max_size);
  
    // Find the first array
    // containing same elements
    System.out.println("First Array is");
    for (int i = 0; i < max_size; i++) 
    {
      System.out.print(max1 + " ");
      v[max1] -= 1;
    }
    System.out.println();
  
    // Find the second array
    // containing unique elements
    System.out.println("The Second Array Is :");
    for (int i = 0; i < (n + 1); i++) 
    {
      if (v[i] > 0
      {
        System.out.print(i + " ");
        max_size--;
      }
      if (max_size < 1)
        break;
    }
    System.out.println();
  }
  
  // Driver Code
  public static void main(String[] args)
  {
    // initialise n
    int n = 7;
  
    // array declaration
    int arr[] = new int[] {1, 2, 1, 5
                           1, 6, 7, 2};
  
    // size of array
    int size = arr.length;
  
    Solve(arr, size, n);
  }
}
  
// This code is contributed by Sri_srajit

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to find the max-size to which
# an array can be divided into 2 equal parts
# such that one part contains unique elements 
# while another contains similar elements
  
# Function to find the max-size to which an 
# array can be divided into 2 equal parts
def Solve(arr, size, n):
  
    v = [0] * (n + 1);
  
    # Vector to find the frequency of
    # each element of list
    for i in range(size):
        v[arr[i]] += 1
  
    # Find the maximum frequency
    # element present in list arr
    max1 = max(set(arr), key = v.count)
      
    # Find total unique elements
    # present in list arr
    diff1 = n + 1 - v.count(0)
  
    # Find the Max-Size to which
    # an array arr[] can be splitted
    max_size = max(min(v[max1] - 1, diff1), 
                   min(v[max1], diff1 - 1))
  
    print("Maximum size is :", max_size)
  
    # Find the first array
    # containing same elements
    print("The First Array Is : ")
    for i in range(max_size):
        print(max1, end = " ")
        v[max1] -= 1
  
    print()
  
    # Find the second array
    # containing unique elements
    print("The Second Array Is : ")
    for i in range(n + 1):
        if (v[i] > 0):
            print(i, end = " ")
            max_size -= 1
          
        if (max_size < 1):
            break
  
    print()
  
# Driver code
if __name__ == "__main__":
      
    # Initialise n
    n = 7
  
    # Array declaration
    arr = [ 1, 2, 1, 5, 1, 6, 7, 2 ]
  
    # Size of array
    size = len(arr)
  
    Solve(arr, size, n)
      
# This code is contributed by chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find the max-size 
// to which an array can be divided
// into 2 equal parts such that one
// part contains unique elements
// while another contains similar
// elements
using System;
  
class GFG{
      
// Function to find the max-size to 
// which an array can be divided into 
// 2 equal parts
static void Solve(int []arr, 
                  int size, int n)
{
    int[] v = new int[n + 1];
  
    // Array to find the frequency of
    // each element of array
    for(int i = 0; i < size; i++)
        v[arr[i]]++;
  
    // Find the index maximum frequency
    // element present in array arr[]
    int max1 = -1, mx = -1;
    for(int i = 0; i < v.Length; i++) 
    {
        if (v[i] > mx) 
        {
            mx = v[i];
            max1 = i;
        }
    }
      
    // Find total unique elements
    // present in array arr[]
    int cnt = 0;
    foreach(int i in v) 
    {
        if (i == 0)
            ++cnt;
    }
      
    int diff1 = n + 1 - cnt;
  
    // Find the Max-Size to which
    // an array arr[] can be splitted
    int max_size = Math.Max(Math.Min(v[max1] - 1, 
                                     diff1),
                            Math.Min(v[max1], 
                                     diff1 - 1));
                                       
    Console.Write("Maximum size is :"
                   max_size + "\n");
  
    // Find the first array
    // containing same elements
    Console.Write("The First Array Is :\n");
      
    for(int i = 0; i < max_size; i++) 
    {
        Console.Write(max1 + " ");
        v[max1] -= 1;
    }
    Console.Write("\n");
  
    // Find the second array
    // containing unique elements
    Console.Write("The Second Array Is :\n");
    for(int i = 0; i < (n + 1); i++) 
    {
        if (v[i] > 0) 
        {
            Console.Write(i + " ");
            max_size--;
        }
        if (max_size < 1)
            break;
    }
    Console.Write("\n");
}
  
// Driver Code
public static void Main(string[] args)
{
      
    // Initialise n
    int n = 7;
  
    // Array declaration
    int []arr = new int[] { 1, 2, 1, 5, 
                            1, 6, 7, 2 };
  
    // Size of array
    int size = arr.Length;
  
    Solve(arr, size, n);
}
}
  
// This code is contributed by rutvik_56

chevron_right


Output: 

Maximum size is :3
The First Array Is : 
1 1 1 
The Second Array Is : 
2 5 6

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :