# Check if an array can be split into subsets of K consecutive elements

• Difficulty Level : Medium
• Last Updated : 21 May, 2021

Given an array arr[] and integer K, the task is to split the array into subsets of size K, such that each subset consists of K consecutive elements.

Examples:

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.

Input: arr[] = {1, 2, 3, 6, 2, 3, 4, 7, 8}, K = 3
Output: true
Explanation:
The given array of length 9 can be split into 3 subsets {1, 2, 3}, {2, 3, 4} and {6, 7, 8} such that each subset consists of 3 consecutive elements.

Input: arr[] = [1, 2, 3, 4, 5], K = 4
Output: false
Explanation:
The given array of length 5 cannot be split into subsets of 4.

Approach
Follow the steps to solve the problem:

• Store the frequencies of all array elements in a HashMap
• Traverse the HashMap.
• For every element present in the HashMap, check if all its occurrences can be grouped in a subsets with its next (K – 1) consecutive elements or not. If so, reduce the frequencies of the elements included in the subsets accordingly in the HashMap and proceed forward.
• If any element is found which cannot be grouped into a subset of K consecutive elements, print False. Otherwise print True.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement the``// above approach``#include ``using` `namespace` `std;` `// Function to check if a given array can``// be split into subsets of K consecutive``// elements``bool` `groupInKConsecutive(vector<``int``>& arr,``                         ``int` `K)``{``    ``// Stores the frequencies of``    ``// array elements``    ``map<``int``, ``int``> count;` `    ``for` `(``int` `h : arr) {``        ``++count[h];``    ``}` `    ``// Traverse the map``    ``for` `(``auto` `c : count) {``        ``int` `cur = c.first;``        ``int` `n = c.second;` `        ``// Check if all its occurrences can``        ``// be grouped into K subsets``        ``if` `(n > 0) {` `            ``// Traverse next K elements``            ``for` `(``int` `i = 1; i < K; ++i) {` `                ``// If the element is not``                ``// present in the array``                ``if` `(!count.count(cur + i)) {``                    ``return` `false``;``                ``}` `                ``count[cur + i] -= n;` `                ``// If it cannot be split into``                ``// required number of subsets``                ``if` `(count[cur + i] < 0)``                    ``return` `false``;``            ``}``        ``}``    ``}` `    ``return` `true``;``}` `// Driver Code``int` `main()``{``    ``vector<``int``> arr = { 1, 2, 3, 6, 2,``                        ``3, 4, 7, 8 };``    ``int` `k = 3;``    ``if` `(groupInKConsecutive(arr, k)) {``        ``cout << ``"True"``;``    ``}``    ``else` `{``        ``cout << ``"False"``;``    ``}``}`

## Java

 `// Java Program to implement the``// above approach``import` `java.util.*;``class` `GFG{` `// Function to check if a given array can``// be split into subsets of K consecutive``// elements``static` `boolean` `groupInKConsecutive(``int``[] arr,``                                    ``int` `K)``{``    ``// Stores the frequencies of``    ``// array elements``    ``HashMap count = ``new` `HashMap();` `    ``for` `(``int` `h : arr)``    ``{``        ``if``(count.containsKey(h))``            ``count.put(h, count.get(h) + ``1``);``        ``else``            ``count.put(h, ``1``);``    ``}` `    ``// Traverse the map``    ``for` `(Map.Entry c : count.entrySet())``    ``{``        ``int` `cur = c.getKey();``        ``int` `n = c.getValue();` `        ``// Check if all its occurrences can``        ``// be grouped into K subsets``        ``if` `(n > ``0``)``        ``{` `            ``// Traverse next K elements``            ``for` `(``int` `i = ``1``; i < K; ++i)``            ``{` `                ``// If the element is not``                ``// present in the array``                ``if` `(!count.containsKey(cur + i))``                ``{``                    ``return` `false``;``                ``}` `                ``count.put(cur + i, count.get(cur + i) - n);` `                ``// If it cannot be split into``                ``// required number of subsets``                ``if` `(count.get(cur + i) < ``0``)``                    ``return` `false``;``            ``}``        ``}``    ``}``    ``return` `true``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int``[] arr = { ``1``, ``2``, ``3``, ``6``, ``2``,``                     ``3``, ``4``, ``7``, ``8` `};``    ``int` `k = ``3``;``    ``if` `(groupInKConsecutive(arr, k))``    ``{``        ``System.out.print(``"True"``);``    ``}``    ``else``    ``{``        ``System.out.print(``"False"``);``    ``}``}``}` `// This code contributed by sapnasingh4991`

## Python3

 `# Python3 program to implement the``# above approach` `from` `collections ``import` `defaultdict` `# Function to check if a given array can``# be split into subsets of K consecutive``# elements``def` `groupInKConsecutive(arr, K):` `    ``# Stores the frequencies of``    ``# array elements``    ``count ``=` `defaultdict(``int``)` `    ``for` `h ``in` `arr:``        ``count[h] ``+``=` `1` `    ``# Traverse the map``    ``for` `key, value ``in` `count.items():``        ``cur ``=` `key``        ``n ``=` `value` `        ``# Check if all its occurrences can``        ``# be grouped into K subsets``        ``if` `(n > ``0``):` `            ``# Traverse next K elements``            ``for` `i ``in` `range``(``1``, K):` `                ``# If the element is not``                ``# present in the array``                ``if` `((cur ``+` `i) ``not` `in` `count):``                    ``return` `False` `                ``count[cur ``+` `i] ``-``=` `n` `                ``# If it cannot be split into``                ``# required number of subsets``                ``if` `(count[cur ``+` `i] < ``0``):``                    ``return` `False``                    ` `    ``return` `True` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``6``, ``2``,``            ``3``, ``4``, ``7``, ``8` `]``    ``k ``=` `3``    ` `    ``if` `(groupInKConsecutive(arr, k)):``        ``print``(``"True"``)``    ``else``:``        ``print``(``"False"``)` `# This code is contributed by chitranayal`

## C#

 `// C# program to implement the``// above approach``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `GFG{`` ` `// Function to check if a given array can``// be split into subsets of K consecutive``// elements``static` `bool` `groupInKConsecutive(``int``[] arr,``                                ``int` `K)``{``    ` `    ``// Stores the frequencies of``    ``// array elements``    ``Dictionary<``int``,``               ``int``> count = ``new` `Dictionary<``int``,``                                           ``int``>();`` ` `    ``foreach``(``int` `h ``in` `arr)``    ``{``        ``if` `(count.ContainsKey(h))``            ``count[h]++;``        ``else``            ``count[h] = 1;``    ``}`` ` `    ``// Traverse the map``    ``foreach``(``int` `c ``in` `count.Keys.ToList())``    ``{``        ``int` `cur = c;``        ``int` `n = count;``        ` `        ``// Check if all its occurrences can``        ``// be grouped into K subsets``        ``if` `(n > 0)``        ``{``            ` `            ``// Traverse next K elements``            ``for``(``int` `i = 1; i < K; ++i)``            ``{``                ` `                ``// If the element is not``                ``// present in the array``                ``if` `(!count.ContainsKey(cur + i))``                ``{``                    ``return` `false``;``                ``}`` ` `                ``count[cur + i] -= n;`` ` `                ``// If it cannot be split into``                ``// required number of subsets``                ``if` `(count[cur + i] < 0)``                    ``return` `false``;``            ``}``        ``}``    ``}``    ``return` `true``;``}`` ` `// Driver Code``public` `static` `void` `Main(``string``[] args)``{``    ``int``[] arr = { 1, 2, 3, 6, 2,``                  ``3, 4, 7, 8 };``    ``int` `k = 3;``    ``if` `(groupInKConsecutive(arr, k))``    ``{``        ``Console.Write(``"True"``);``    ``}``    ``else``    ``{``        ``Console.Write(``"False"``);``    ``}``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``
Output:
`True`

Time Complexity: O(N*log(N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up