Skip to content
Related Articles

# Divide array in two maximum equal length arrays of similar and dissimilar elements

• Last Updated : 26 May, 2021

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++

 `// 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 ``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;``}`

## Java

 `// 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`

## Python3

 `# 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`

## C#

 `// 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`

## Javascript

 ``
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 mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up