# Check if a string can be split into two strings with same number of K-frequent characters

Given a string S and an integer K, the task is to check if it is possible to distribute these characters into two strings such that count of characters having a frequency K in both strings is equal.
If it is possible, then print a sequence consisting of 1 and 2, which denotes which character should be placed in which string. Otherwise, print NO.

Note: One of these new strings can be empty.

Examples:

Input: S = “abbbccc”, K = 1
Output: 1111211
Explanation:
The two strings are “abbbcc” and “c”.
Hence, both the strings have exactly 1 character having frequency K( = 1).

Input: S = “aaaa”, K = 3
Output: 1111
Explanation:
String can be split into “aaaa” and “”.
Hence, no character has frequency 3 in both the strings.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:
Follow the steps below to solve the problem:

• Check for the following three conditions to determine if a split is possible or not:

1. If the total number of characters having a frequency K in the initial string is even, then these characters can be placed equally into two strings and the rest of the characters(having a frequency not equal to K) can be placed in any of the two groups.
2. If the total number of characters having a frequency K in the initial string is odd, then if there is a character in the initial string having a frequency greater than K but not equal to 2K, then such a distribution is possible.

Illustration:
S =”abceeee”, K = 1

Split into “abeee” and “ce”. Hence, both the strings have 2 characters with frequency 1.

3. If the total number of characters having a frequency K in the initial string is odd, then if there is a character in the initial string having a frequency equal to 2K, then such distribution is possible.

Illustration:
S =”aaaabbccdde”, K = 2

Split into “aabbc” and “aaddce” so that both the strings have two characters with frequency 2.

• If all the three condition mentioned above fails then answer is “NO”.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the ` `// above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to print the ` `// arrangement of characters ` `void` `DivideString(string s, ``int` `n, ` `                  ``int` `k) ` `{ ` `    ``int` `i, c = 0, no = 1; ` `    ``int` `c1 = 0, c2 = 0; ` ` `  `    ``// Stores frequency of ` `    ``// characters ` `    ``int` `fr = { 0 }; ` ` `  `    ``string ans = ``""``; ` ` `  `    ``for` `(i = 0; i < n; i++) { ` `        ``fr[s[i] - ``'a'``]++; ` `    ``} ` ` `  `    ``char` `ch, ch1; ` `    ``for` `(i = 0; i < 26; i++) { ` ` `  `        ``// Count the character ` `        ``// having frequency K ` `        ``if` `(fr[i] == k) { ` `            ``c++; ` `        ``} ` ` `  `        ``// Count the character ` `        ``// having frequency ` `        ``// greater than K and ` `        ``// not equal to 2K ` `        ``if` `(fr[i] > k ` `            ``&& fr[i] != 2 * k) { ` `            ``c1++; ` `            ``ch = i + ``'a'``; ` `        ``} ` ` `  `        ``if` `(fr[i] == 2 * k) { ` `            ``c2++; ` `            ``ch1 = i + ``'a'``; ` `        ``} ` `    ``} ` ` `  `    ``for` `(i = 0; i < n; i++) ` `        ``ans = ans + ``"1"``; ` ` `  `    ``map<``char``, ``int``> mp; ` `    ``if` `(c % 2 == 0 || c1 > 0 || c2 > 0) { ` `        ``for` `(i = 0; i < n; i++) { ` ` `  `            ``// Case 1 ` `            ``if` `(fr[s[i] - ``'a'``] == k) { ` `                ``if` `(mp.find(s[i]) ` `                    ``!= mp.end()) { ` `                    ``ans[i] = ``'2'``; ` `                ``} ` `                ``else` `{ ` `                    ``if` `(no <= (c / 2)) { ` `                        ``ans[i] = ``'2'``; ` `                        ``no++; ` `                        ``mp[s[i]] = 1; ` `                    ``} ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Case 2 ` `        ``if` `(c % 2 == 1 && c1 > 0) { ` `            ``no = 1; ` `            ``for` `(i = 0; i < n; i++) { ` `                ``if` `(s[i] == ch && no <= k) { ` ` `  `                    ``ans[i] = ``'2'``; ` `                    ``no++; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// Case 3 ` `        ``if` `(c % 2 == 1 && c1 == 0) { ` `            ``no = 1; ` `            ``int` `flag = 0; ` `            ``for` `(``int` `i = 0; i < n; i++) { ` `                ``if` `(s[i] == ch1 && no <= k) { ` `                    ``ans[i] = ``'2'``; ` `                    ``no++; ` `                ``} ` `                ``if` `(fr[s[i] - ``'a'``] == k ` `                    ``&& flag == 0 ` `                    ``&& ans[i] == ``'1'``) { ` `                    ``ans[i] = ``'2'``; ` `                    ``flag = 1; ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``cout << ans << endl; ` `    ``} ` `    ``else` `{ ` `        ``// If all cases fail ` `        ``cout << ``"NO"` `<< endl; ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` ` `  `    ``string S = ``"abbbccc"``; ` `    ``int` `N = S.size(); ` `    ``int` `K = 1; ` ` `  `    ``DivideString(S, N, K); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for the above problem  ` `import` `java.util.*;  ` ` `  `class` `GFG{ ` `     `  `// Function to print the  ` `// arrangement of characters  ` `public` `static` `void` `DivideString(String s, ``int` `n,  ` `                                          ``int` `k)  ` `{  ` `    ``int` `i, c = ``0``, no = ``1``;  ` `    ``int` `c1 = ``0``, c2 = ``0``;  ` ` `  `    ``// Stores frequency of  ` `    ``// characters  ` `    ``int``[] fr = ``new` `int``[``26``];  ` ` `  `    ``char``[] ans = ``new` `char``[n];  ` ` `  `    ``for``(i = ``0``; i < n; i++) ` `    ``{  ` `        ``fr[s.charAt(i) - ``'a'``]++;  ` `    ``}  ` ` `  `    ``char` `ch = ``'a'``, ch1 = ``'a'``;  ` `    ``for``(i = ``0``; i < ``26``; i++) ` `    ``{  ` `         `  `        ``// Count the character  ` `        ``// having frequency K  ` `        ``if` `(fr[i] == k)  ` `        ``{  ` `            ``c++;  ` `        ``}  ` ` `  `        ``// Count the character  ` `        ``// having frequency  ` `        ``// greater than K and  ` `        ``// not equal to 2K  ` `        ``if` `(fr[i] > k && fr[i] != ``2` `* k) ` `        ``{  ` `            ``c1++;  ` `            ``ch = (``char``)(i + ``'a'``);  ` `        ``}  ` ` `  `        ``if` `(fr[i] == ``2` `* k)  ` `        ``{  ` `            ``c2++;  ` `            ``ch1 = (``char``)(i + ``'a'``);  ` `        ``}  ` `    ``}  ` ` `  `    ``for``(i = ``0``; i < n; i++)  ` `        ``ans[i] = ``'1'``;  ` `     `  `    ``HashMap mp = ``new` `HashMap<>();  ` ` `  `    ``if` `(c % ``2` `== ``0` `|| c1 > ``0` `|| c2 > ``0``) ` `    ``{  ` `        ``for``(i = ``0``; i < n; i++)  ` `        ``{  ` ` `  `            ``// Case 1  ` `            ``if` `(fr[s.charAt(i) - ``'a'``] == k)  ` `            ``{  ` `                ``if` `(mp.containsKey(s.charAt(i))) ` `                ``{  ` `                    ``ans[i] = ``'2'``;  ` `                ``}  ` `                ``else`  `                ``{  ` `                    ``if` `(no <= (c / ``2``)) ` `                    ``{  ` `                        ``ans[i] = ``'2'``;  ` `                        ``no++;  ` `                        ``mp.replace(s.charAt(i), ``1``); ` `                    ``}  ` `                ``}  ` `            ``}  ` `        ``}  ` ` `  `        ``// Case 2  ` `        ``if` `( (c % ``2` `== ``1``) && (c1 > ``0``) ) ` `        ``{  ` `            ``no = ``1``;  ` `            ``for``(i = ``0``; i < n; i++) ` `            ``{  ` `                ``if` `(s.charAt(i) == ch && no <= k)  ` `                ``{  ` `                    ``ans[i] = ``'2'``;  ` `                    ``no++;  ` `                ``}  ` `            ``}  ` `        ``}  ` ` `  `        ``// Case 3  ` `        ``if` `(c % ``2` `== ``1` `&& c1 == ``0``)  ` `        ``{  ` `            ``no = ``1``;  ` `            ``int` `flag = ``0``;  ` `             `  `            ``for``(i = ``0``; i < n; i++) ` `            ``{  ` `                ``if` `(s.charAt(i) == ch1 && no <= k)  ` `                ``{  ` `                    ``ans[i] = ``'2'``;  ` `                    ``no++;  ` `                ``}  ` `                ``if` `(fr[s.charAt(i) - ``'a'``] == k &&  ` `                      ``flag == ``0` `&& ans[i] == ``'1'``) ` `                ``{  ` `                    ``ans[i] = ``'2'``;  ` `                    ``flag = ``1``;  ` `                ``}  ` `            ``}  ` `        ``}  ` `        ``System.out.println(ans); ` `    ``}  ` `    ``else` `    ``{ ` `         `  `        ``// If all cases fail ` `        ``System.out.println(``"NO"``); ` `    ``}  ` `}  ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``String S = ``"abbbccc"``;  ` `    ``int` `N = S.length();  ` `    ``int` `K = ``1``;  ` ` `  `    ``DivideString(S, N, K);  ` `} ` `} ` ` `  `// This code is contributed by divyeshrabadiya07 `

## Python3

 `# Python3 implementation of the ` `# above approach ` ` `  `# Function to print the ` `# arrangement of characters ` `def` `DivideString(s, n, k): ` `     `  `    ``c ``=` `0` `    ``no ``=` `1` `    ``c1 ``=` `0` `    ``c2 ``=` `0` ` `  `    ``# Stores frequency of ` `    ``# characters ` `    ``fr ``=` `[``0``] ``*` `26` ` `  `    ``ans ``=` `[] ` `    ``for` `i ``in` `range``(n): ` `        ``fr[``ord``(s[i]) ``-` `ord``(``'a'``)] ``+``=` `1` ` `  `    ``for` `i ``in` `range``(``26``): ` ` `  `        ``# Count the character ` `        ``# having frequency K ` `        ``if` `(fr[i] ``=``=` `k): ` `            ``c ``+``=` `1` ` `  `        ``# Count the character having ` `        ``# frequency greater than K and ` `        ``# not equal to 2K ` `        ``if` `(fr[i] > k ``and` `fr[i] !``=` `2` `*` `k): ` `            ``c1 ``+``=` `1` `            ``ch ``=` `chr``(``ord``(``'a'``) ``+` `i) ` ` `  `        ``if` `(fr[i] ``=``=` `2` `*` `k): ` `            ``c2 ``+``=` `1` `            ``ch1 ``=` `chr``(``ord``(``'a'``) ``+` `i) ` ` `  `    ``for` `i ``in` `range``(n): ` `        ``ans.append(``"1"``) ` ` `  `    ``mp ``=` `{} ` `    ``if` `(c ``%` `2` `=``=` `0` `or` `c1 > ``0` `or` `c2 > ``0``): ` `        ``for` `i ``in` `range``(n): ` `             `  `            ``# Case 1 ` `            ``if` `(fr[``ord``(s[i]) ``-` `ord``(``'a'``)] ``=``=` `k): ` `                ``if` `(s[i] ``in` `mp): ` `                    ``ans[i] ``=` `'2'` ` `  `                ``else``: ` `                    ``if` `(no <``=` `(c ``/``/` `2``)): ` `                        ``ans[i] ``=` `'2'` `                        ``no ``+``=` `1` `                        ``mp[s[i]] ``=` `1` `                         `  `        ``# Case 2 ` `        ``if` `(c ``%` `2` `=``=` `1` `and` `c1 > ``0``): ` `            ``no ``=` `1` `            ``for` `i ``in` `range``(n): ` `                ``if` `(s[i] ``=``=` `ch ``and` `no <``=` `k): ` `                    ``ans[i] ``=` `'2'` `                    ``no ``+``=` `1` `                     `  `        ``# Case 3 ` `        ``if` `(c ``%` `2` `=``=` `1` `and` `c1 ``=``=` `0``): ` `            ``no ``=` `1` `            ``flag ``=` `0` `             `  `            ``for` `i ``in` `range``(n): ` `                ``if` `(s[i] ``=``=` `ch1 ``and` `no <``=` `k): ` `                    ``ans[i] ``=` `'2'` `                    ``no ``+``=` `1` `                     `  `                ``if` `(fr[s[i] ``-` `'a'``] ``=``=` `k ``and`  `                              ``flag ``=``=` `0` `and`  `                            ``ans[i] ``=``=` `'1'``): ` `                    ``ans[i] ``=` `'2'` `                    ``flag ``=` `1` ` `  `        ``print``("".join(ans)) ` `    ``else``: ` `         `  `        ``# If all cases fail ` `        ``print``(``"NO"``) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``S ``=` `"abbbccc"` `    ``N ``=` `len``(S) ` `    ``K ``=` `1` ` `  `    ``DivideString(S, N, K) ` ` `  `# This code is contributed by mohit kumar 29 `

Output:

```1111211
```

Time Complexity: O(N)
Auxiliary Space: 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 Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.