Skip to content
Related Articles

Related Articles

Improve Article

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



<script>
 
// Javascript 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 leto
  // 2 equal parts
  function Solve(arr, size, n)
  {
    let v = Array.from({length: n+1}, (_, i) => 0);
   
    // Array to find the frequency of
    // each element of array
    for (let i = 0; i < size; i++)
      v[arr[i]]++;
   
    // Find the index maximum frequency
    // element present in array arr[]
    let max1 = -1, mx = -1;
    for (let i = 0; i < v.length; i++)
    {
      if (v[i] > mx)
      {
        mx = v[i];
        max1 = i;
      }
    }
    // Find total unique elements
    // present in array arr[]
    let cnt = 0;
    for (let i in v)
    {
      if (i == 0)
        ++cnt;
    }
    let diff1 = n + 1 - cnt;
   
    // Find the Max-Size to which
    // an array arr[] can be splitted
    let max_size = Math.max(Math.min(v[max1] - 1,
                                     diff1),
                            Math.min(v[max1],
                                     diff1 - 1));
    document.write("Maximum size is: " +
                        max_size + "<br/>");
   
    // Find the first array
    // containing same elements
    document.write("First Array is" + "<br/>");
    for (let i = 0; i < max_size; i++)
    {
      document.write(max1 + " ");
      v[max1] -= 1;
    }
    document.write("<br/>");
   
    // Find the second array
    // containing unique elements
    document.write("The Second Array Is :" + "<br/>");
    for (let i = 0; i < (n + 1); i++)
    {
      if (v[i] > 0)
      {
        document.write(i + " ");
        max_size--;
      }
      if (max_size < 1)
        break;
    }
    document.write("<br/>");
  }
 
// Driver code
     
      // initialise n
    let n = 7;
   
    // array declaration
    let arr = [1, 2, 1, 5,
                     1, 6, 7, 2];
   
    // size of array
    let size = arr.length;
   
    Solve(arr, size, n);
    
   // This code is contributed by code_hunt.
</script>
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
Previous
Sum and Product of all even digit sum Nodes of a Singly Linked List
Next

Nth positive number whose absolute difference of adjacent digits is at most 1
Recommended Articles
Page :
Minimum swaps of similar indexed elements required to make all elements of one of the two given arrays equal
02, Dec 20
Divide array into two sub-arrays such that their averages are equal
27, Jan 17
Rearrange array to make Bitwise XOR of similar indexed elements of two arrays is same
27, Oct 20
Count N-length arrays of made up of elements not exceeding 2^K - 1 having maximum sum and Bitwise AND equal to 0
23, Jul 21
Bitwise XOR of same indexed array elements after rearranging an array to make XOR of same indexed elements of two arrays equal
05, Aug 21
Number of ways to divide an array into K equal sum sub-arrays
27, May 19
Count all N-length arrays made up of distinct consecutive elements whose first and last elements are equal
06, Jan 21
Maximize sum of product of same-indexed elements of equal length subarrays obtained from two given arrays
30, Apr 21
Minimum flips of odd indexed elements from odd length subarrays to make two given arrays equal
02, Dec 20
Divide array into two arrays which does not contain any pair with sum K
03, Nov 20
Minimize sum of product of same-indexed elements of two arrays by reversing a subarray of one of the two arrays
31, May 21
Divide the array into minimum number of sub-arrays having unique elements
21, Oct 19
Equally divide into two sets such that one set has maximum distinct elements
04, Sep 18
Ways to divide a binary array into sub-arrays such that each sub-array contains exactly one 1
28, Jan 19
Find sub-arrays from given two arrays such that they have equal sum
02, May 19
Check if two arrays can be made equal by swapping pairs of one of the arrays
03, Feb 21
Maximum sum of Bitwise XOR of all elements of two equal length subsets
21, Aug 20
Divide array in two Subsets such that sum of square of sum of both subsets is maximum
07, Feb 20
Count of arrays in which all adjacent elements are such that one of them divide the another
02, May 17
Split an array into equal length subsequences consisting of equal elements only
13, Jan 21
Minimize length of an array by removing similar subarrays from both ends
09, Feb 21
Count of N-size maximum sum Arrays with elements in range [0, 2^K – 1] and Bitwise AND equal to 0
09, Jul 21
Find all numbers that divide maximum array elements
25, Nov 18
Generate an N-length array having length of non-decreasing subarrays maximized and minimum difference between first and last array elements
23, Jul 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
epistler_999
@epistler_999
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox