# Split an array containing N elements into K sets of distinct elements

Given two integers N and K and an array arr[] consisting of duplicate elements, the task is to split N elements into K sets of distinct elements.
Examples:

Input: N = 5, K = 2, arr[] = {3, 2, 1, 2, 3}
Output:
( 3 2 1 )
( 2 3 )
Input: N = 5, K = 2, arr[] = {2, 1, 1, 2, 1}
Output: -1
Explanation:
It is not possible to split all the elements into K sets of distinct elements as 1 appears more than K times in the array.

Approach: In order to solve the problem, we are using a map to store the frequency of every element. If the frequency of any element exceeds K, print -1. Maintain another map to store the sets for every respective frequencies. If no element has a frequency greater than K, print the sets for all corresponding frequencies as the required set.
Below is the implementation of the above approach:

## C++

 `// C++ Program to split N elements``// into exactly K sets consisting``// of no distinct elements` `#include ``using` `namespace` `std;` `// Function to check if possible to``// split N elements into exactly K``// sets consisting of no distinct elements``void` `splitSets(``int` `a[], ``int` `n, ``int` `k)``{``    ``// Store the frequency``    ``// of each element``    ``map<``int``, ``int``> freq;` `    ``// Store the required sets``    ``map<``int``, vector<``int``> > ans;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``// If frequency of a``        ``// particular element``        ``// exceeds K``        ``if` `(freq[a[i]] + 1 > k) {``            ``// Not possible``            ``cout << -1 << endl;``            ``return``;``        ``}` `        ``// Increase the frequency``        ``freq[a[i]] += 1;``        ``// Store the element for the``        ``// respective set``        ``ans[freq[a[i]]].push_back(a[i]);``    ``}` `    ``// Display the sets``    ``for` `(``auto` `it : ans) {``        ``cout << ``"( "``;``        ``for` `(``int` `i : it.second) {``            ``cout << i << ``" "``;``        ``}``        ``cout << ``")\n"``;``    ``}``}` `// Driver code``int` `main()``{` `    ``int` `arr[] = { 2, 1, 2, 3, 1,``                  ``4, 1, 3, 1, 4 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);` `    ``int` `k = 4;` `    ``splitSets(arr, n, k);` `    ``return` `0;``}`

## Java

 `// Java program to split N elements ``// into exactly K sets consisting ``// of no distinct elements ``import` `java.util.*;` `class` `GFG{``    ` `// Function to check if possible to``// split N elements into exactly K``// sets consisting of no distinct elements``static` `void` `splitSets(``int` `a[], ``int` `n, ``int` `k)``{``    ` `    ``// Store the frequency``    ``// of each element``    ``Map freq = ``new` `HashMap<>();` `    ``// Store the required sets``    ``Map> ans = ``new` `HashMap<>();` `    ``for``(``int` `i = ``0``; i < n; i++)``    ``{``        ` `        ``// If frequency of a``        ``// particular element``        ``// exceeds K``        ``if``(freq.get(a[i]) != ``null``)``        ``{``            ``if` `(freq.get(a[i]) + ``1` `> k) ``            ``{``                ` `                ``// Not possible``                ``System.out.println(-``1``);``                ``return``;``            ``}``        ``}``        ` `        ``// Increase the frequency``        ``freq.put(a[i], freq.getOrDefault(a[i], ``0``) + ``1` `);``        ` `        ``// Store the element for the``        ``// respective set``        ``if``( ans.get(freq.get(a[i])) == ``null``)``            ``ans.put(freq.get(a[i]),``                    ``new` `ArrayList());``        ` `        ``ans.get(freq.get(a[i])).add(a[i]);``    ``}``    ` `    ``// Display the sets``    ``for``(ArrayList it : ans.values())``    ``{``        ``System.out.print(``"( "``);``        ``for``(``int` `i = ``0``; i < it.size() - ``1``; i++)``        ``{``            ``System.out.print(it.get(i) + ``" "``);``        ``}``        ` `        ``System.out.print(it.get(it.size() - ``1``));``        ``System.out.println(``" )"``);``    ``}``}` `// Driver code    ``public` `static` `void` `main (String[] args)``{``    ``int` `arr[] = { ``2``, ``1``, ``2``, ``3``, ``1``,``                  ``4``, ``1``, ``3``, ``1``, ``4` `};``                ` `    ``int` `n = arr.length;``    ``int` `k = ``4``;``    ` `    ``splitSets(arr, n, k);``}``}` `// This code is contributed by coder001`

## Python3

 `# Python3 Program to split N elements ``# into exactly K sets consisting ``# of no distinct elements ` `# Function to check if possible to ``# split N elements into exactly K ``# sets consisting of no distinct elements ``def` `splitSets(a, n, k) : ` `    ``# Store the frequency ``    ``# of each element ``    ``freq ``=` `{} ` `    ``# Store the required sets ``    ``ans ``=` `{}` `    ``for` `i ``in` `range``(n) :``      ` `        ``# If frequency of a ``        ``# particular element ``        ``# exceeds K ``        ``if` `a[i] ``in` `freq :``            ``if` `freq[a[i]] ``+` `1` `> k :``              ` `                ``# Not possible``                ``print``(``-``1``)``                ``return` `        ``# Increase the frequency ``        ``if` `a[i] ``in` `freq :``            ``freq[a[i]] ``+``=` `1``        ``else` `:``            ``freq[a[i]] ``=` `1``    ` `        ``# Store the element for the ``        ``# respective set ``        ``if` `freq[a[i]] ``in` `ans :``            ``ans[freq[a[i]]].append(a[i])``        ``else` `:``            ``ans[freq[a[i]]] ``=` `[a[i]]``     ` `    ``# Display the sets ``    ``for` `it ``in` `ans :``        ``print``(``"( "``, end ``=` `"") ``        ``for` `i ``in` `ans[it] : ``            ``print``(i , end ``=` `" "``)``    ` `        ``print``(``")"``) ` `arr ``=` `[ ``2``, ``1``, ``2``, ``3``, ``1``, ``4``, ``1``, ``3``, ``1``, ``4` `] ``n ``=` `len``(arr)` `k ``=` `4` `splitSets(arr, n, k)` `# This code is contributed by divyesh072019`

## C#

 `// C# Program to split N elements``// into exactly K sets consisting``// of no distinct elements``using` `System;``using` `System.Collections.Generic;``class` `GFG ``{` `  ``// Function to check if possible to``  ``// split N elements into exactly K``  ``// sets consisting of no distinct elements``  ``static` `void` `splitSets(``int``[] a, ``int` `n, ``int` `k)``  ``{``    ``// Store the frequency``    ``// of each element``    ``Dictionary<``int``, ``int``> freq = ``new` `Dictionary<``int``, ``int``>();` `    ``// Store the required sets``    ``Dictionary<``int``, List<``int``>> ans = ``new` `Dictionary<``int``, List<``int``>>();` `    ``for` `(``int` `i = 0; i < n; i++) ``    ``{` `      ``// If frequency of a``      ``// particular element``      ``// exceeds K``      ``if``(freq.ContainsKey(a[i]))``      ``{``        ``if``(freq[a[i]] + 1 > k)``        ``{` `          ``// Not possible``          ``Console.WriteLine(-1);``          ``return``;``        ``}``      ``}``      ``else` `if``(1 > k)``      ``{``        ` `        ``// Not possible``        ``Console.WriteLine(-1);``        ``return``;``      ``}` `      ``// Increase the frequency``      ``if``(freq.ContainsKey(a[i]))``      ``{``        ``freq[a[i]] += 1;``      ``}``      ``else``      ``{``        ``freq[a[i]] = 1;``      ``}` `      ``// Store the element for the``      ``// respective set``      ``if``(ans.ContainsKey(freq[a[i]]))``      ``{``        ``ans[freq[a[i]]].Add(a[i]);``      ``}``      ``else``      ``{``        ``ans[freq[a[i]]] = ``new` `List<``int``>();``        ``ans[freq[a[i]]].Add(a[i]);``      ``}` `    ``}` `    ``// Display the sets``    ``foreach``(KeyValuePair<``int``, List<``int``>> it ``in` `ans)``    ``{``      ``Console.Write(``"( "``);``      ``foreach``(``int` `i ``in` `it.Value)``      ``{``        ``Console.Write(i + ``" "``);``      ``}``      ``Console.WriteLine(``")"``);``    ``}``  ``}` `  ``// Driver code``  ``static` `void` `Main()``  ``{``    ``int``[] arr = { 2, 1, 2, 3, 1,``                 ``4, 1, 3, 1, 4 };``    ``int` `n = arr.Length;``    ``int` `k = 4;``    ``splitSets(arr, n, k);``  ``}``}` `// This code is contributed by divyeshrabadiya07`

## Javascript

 `// JS Program to split N elements``// into exactly K sets consisting``// of no distinct elements` `// Function to check if possible to``// split N elements into exactly K``// sets consisting of no distinct elements``function` `splitSets(a, n, k)``{` `    ``// Store the frequency``    ``// of each element``    ``let freq = {};` `    ``// Store the required sets``    ``let ans = {};` `    ``for` `(``var` `i = 0; i < n; i++) {``        ``// If frequency of a``        ``// particular element``        ``// exceeds K``        ``if` `(freq[a[i]] + 1 > k) {``            ``// Not possible``            ``console.log (-1);``            ``return``;``        ``}` `        ``// Increase the frequency``        ``if` `(!freq.hasOwnProperty(a[i]))``            ``freq[a[i]] = 0``        ``freq[a[i]] += 1;``        ` `        ``// Store the element for the``        ``// respective set``        ``if` `(!ans.hasOwnProperty(freq[a[i]]))``            ``ans[freq[a[i]]] = []``        ``ans[freq[a[i]]].push(a[i]);``    ``}` `    ``// Display the sets``    ``for` `(``var` `[k, it] of Object.entries(ans)) {``        ``console.log(``"("``, it.join(``" "``), ``")"``)``    ``}``}`  `// Driver code``let arr = [ 2, 1, 2, 3, 1, 4, 1, 3, 1, 4 ];``let n = arr.length;``let k = 4;``splitSets(arr, n, k);` `// This code is contributed by phasing17`

Output:
```( 2 1 3 4 )
( 2 1 3 4 )
( 1 )
( 1 )```

Time complexity: O(nlogn) since using a for loop

Auxiliary Space: O(n)

Previous
Next