Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Partition the string in two parts such that both parts have at least k different characters

  • Difficulty Level : Hard
  • Last Updated : 30 Sep, 2021

Given a string of lowercase English alphabets and an integer 0 < K <= 26. The task is to divide the string into two parts (also print them) such that both parts have at least k different characters. If there are more than one answers possible, print one having the smallest left part. If there is no such answers, print “Not Possible”.
Examples: 
 

Input : str = “geeksforgeeks”, k = 4 
Output : geeks , forgeeks 
The string can be divided into two parts as “geeks” and “forgeeks”. Since “geeks” has four different characters ‘g’, ‘e’, ‘k’ and ‘s’ and this is the smallest left part, “forgeeks” has also at least four different characters.
Input : str = “aaaabbbb”, k = 2 
Output :Not Possible 
 

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.

 



Approach : 
 

  • Idea is to count the number of distinct characters using a Hashmap.
  • If the count of the distinct variable becomes equal to k, then the left part of the string is found so store this index, break the loop and unmark all the characters.
  • Now run a loop from where the left string ends to end of the given string and repeat the same process as it was done to find the left string.
  • If count is greater than or equal to k, then right string could be found otherwise print “Not Possible”.
  • If it is possible , then print the left string and right string.

Below is the implementation of the above approach 
 

C++




// C++ implementation of the above approach
#include <iostream>
#include <map>
using namespace std;
 
// Function to find the partition of the
// string such that both parts have at
// least k different characters
void division_of_string(string str, int k)
{
    // Length of the string
    int n = str.size();
 
    // To check if the current
    // character is already found
    map<char, bool> has;
 
    int ans, cnt = 0, i = 0;
 
    // Count number of different
    // characters in the left part
    while (i < n) {
 
        // If current character is not
        // already found, increase cnt by 1
        if (!has[str[i]]) {
            cnt++;
            has[str[i]] = true;
        }
 
        // If count becomes equal to k, we've
        // got the first part, therefore,
        // store current index and break the loop
        if (cnt == k) {
            ans = i;
            break;
        }
 
        i++;
    }
    //Increment i by 1
    i++;
 
    // Clear the map
    has.clear();
 
    // Assign cnt as 0
    cnt = 0;
 
    while (i < n) {
 
        // If the current character is not
        // already found, increase cnt by 1
        if (!has[str[i]]) {
            cnt++;
            has[str[i]] = true;
        }
 
        // If cnt becomes equal to k, the
        // second part also have k different
        // characters so break it
        if (cnt == k) {
            break;
        }
 
        i++;
    }
 
    // If the second part has less than
    // k different characters, then
    // print "Not Possible"
    if (cnt < k) {
        cout << "Not possible" << endl;
    }
 
    // Otherwise print both parts
    else {
        i = 0;
        while (i <= ans) {
            cout << str[i];
            i++;
        }
        cout << endl;
 
        while (i < n) {
            cout << str[i];
            i++;
        }
        cout << endl;
    }
 
    cout << endl;
}
 
// Driver code
int main()
{
    string str = "geeksforgeeks";
    int k = 4;
 
    // Function call
    division_of_string(str, k);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to find the partition of the
// string such that both parts have at
// least k different characters
static void division_of_string(char[] str, int k)
{
    // Length of the string
    int n = str.length;
 
    // To check if the current
    // character is already found
    Map<Character, Boolean> has = new HashMap<>();
 
    int ans = 0, cnt = 0, i = 0;
 
    // Count number of different
    // characters in the left part
    while (i < n)
    {
 
        // If current character is not
        // already found, increase cnt by 1
        if (!has.containsKey(str[i]))
        {
            cnt++;
            has.put(str[i], true);
        }
 
        // If count becomes equal to k, we've
        // got the first part, therefore,
        // store current index and break the loop
        if (cnt == k)
        {
            ans = i;
            break;
        }
 
        i++;
    }
    //Increment i by 1
    i++;
   
    // Clear the map
    has.clear();
 
    // Assign cnt as 0
    cnt = 0;
 
    while (i < n)
    {
 
        // If the current character is not
        // already found, increase cnt by 1
        if (!has.containsKey(str[i]))
        {
            cnt++;
            has.put(str[i], true);
        }
 
        // If cnt becomes equal to k, the
        // second part also have k different
        // characters so break it
        if (cnt == k)
        {
            break;
        }
 
        i++;
    }
 
    // If the second part has less than
    // k different characters, then
    // print "Not Possible"
    if (cnt < k)
    {
        System.out.println("Not possible");
    }
 
    // Otherwise print both parts
    else
    {
        i = 0;
        while (i <= ans)
        {
            System.out.print(str[i]);
            i++;
        }
        System.out.println("");
 
        while (i < n)
        {
            System.out.print(str[i]);
            i++;
        }
        System.out.println("");
    }
 
    System.out.println("");
}
 
// Driver code
public static void main(String[] args)
{
    String str = "geeksforgeeks";
    int k = 4;
 
    // Function call
    division_of_string(str.toCharArray(), k);
}
}
 
// This code is contributed by 29AjayKumar
Python3



# Python3 implementation of the above approach
 
# Function to find the partition of the
# string such that both parts have at
# least k different characters
def division_of_string(string, k) :
     
    # Length of the string
    n = len(string);
 
    # To check if the current
    # character is already found
    has = {};
 
    cnt = 0; i = 0;
 
    # Count number of different
    # characters in the left part
    while (i < n) :
 
        # If current character is not
        # already found, increase cnt by 1
        if string[i] not in has :
            cnt += 1;
            has[string[i]] = True;
 
        # If count becomes equal to k, we've
        # got the first part, therefore,
        # store current index and break the loop
        if (cnt == k) :
            ans = i;
            break;
 
        i += 1;
 
    # Increment i by 1
    i += 1;
     
    # Clear the map
    has.clear();
 
    # Assign cnt as 0
    cnt = 0;
 
    while (i < n) :
 
        # If the current character is not
        # already found, increase cnt by 1
        if (string[i] not in has) :
            cnt += 1;
            has[string[i]] = True;
 
        # If cnt becomes equal to k, the
        # second part also have k different
        # characters so break it
        if (cnt == k) :
            break;
 
        i += 1;
 
    # If the second part has less than
    # k different characters, then
    # print "Not Possible"
    if (cnt < k) :
        print("Not possible",end = "");
 
    # Otherwise print both parts
    else :
        i = 0;
        while (i <= ans) :
            print(string[i],end= "");
            i += 1;
     
        print();
 
        while (i < n) :
            print(string[i],end="");
            i += 1;
             
        print()
 
# Driver code
if __name__ == "__main__":
 
    string = "geeksforgeeks";
    k = 4;
 
    # Function call
    division_of_string(string, k);
 
# This code is contributed by AnkitRai01
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;
 
class GFG
{
 
// Function to find the partition of the
// string such that both parts have at
// least k different characters
static void division_of_string(char[] str, int k)
{
    // Length of the string
    int n = str.Length;
 
    // To check if the current
    // character is already found
    Dictionary<char,bool> has = new Dictionary<char,bool> ();
 
    int ans = 0, cnt = 0, i = 0;
 
    // Count number of different
    // characters in the left part
    while (i < n)
    {
 
        // If current character is not
        // already found, increase cnt by 1
        if (!has.ContainsKey(str[i]))
        {
            cnt++;
            has.Add(str[i], true);
        }
 
        // If count becomes equal to k, we've
        // got the first part, therefore,
        // store current index and break the loop
        if (cnt == k)
        {
            ans = i;
            break;
        }
 
        i++;
    }
    // Increment i by 1
    i++;
 
    // Clear the map
    has.Clear();
 
    // Assign cnt as 0
    cnt = 0;
 
    while (i < n)
    {
 
        // If the current character is not
        // already found, increase cnt by 1
        if (!has.ContainsKey(str[i]))
        {
            cnt++;
            has.Add(str[i], true);
        }
 
        // If cnt becomes equal to k, the
        // second part also have k different
        // characters so break it
        if (cnt == k)
        {
            break;
        }
 
        i++;
    }
   
    // If the second part has less than
    // k different characters, then
    // print "Not Possible"
    if (cnt < k)
    {
        Console.WriteLine("Not possible");
    }
 
    // Otherwise print both parts
    else
    {
        i = 0;
        while (i <= ans)
        {
            Console.Write(str[i]);
            i++;
        }
        Console.WriteLine("");
 
        while (i < n)
        {
            Console.Write(str[i]);
            i++;
        }
        Console.WriteLine("");
    }
 
    Console.WriteLine("");
}
 
// Driver code
public static void Main(String[] args)
{
    String str = "geeksforgeeks";
    int k = 4;
 
    // Function call
    division_of_string(str.ToCharArray(), k);
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
    // Javascript implementation of the approach
 
// Function to find the partition of the
// string such that both parts have at
// least k different characters
function division_of_string(str, k)
{
    // Length of the string
    let n = str.length;
   
    // To check if the current
    // character is already found
    let has = new Map();
   
    let ans = 0, cnt = 0, i = 0;
   
    // Count number of different
    // characters in the left part
    while (i < n)
    {
   
        // If current character is not
        // already found, increase cnt by 1
        if (!has.has(str[i]))
        {
            cnt++;
            has.set(str[i], true);
        }
   
        // If count becomes equal to k, we've
        // got the first part, therefore,
        // store current index and break the loop
        if (cnt == k)
        {
            ans = i;
            break;
        }
   
        i++;
    }
     
    //Increment i by 1
    i++;
   
    // Clear the map
    has.clear();
   
    // Assign cnt as 0
    cnt = 0;
   
    while (i < n)
    {
   
        // If the current character is not
        // already found, increase cnt by 1
        if (!has.has(str[i]))
        {
            cnt++;
            has.set(str[i], true);
        }
   
        // If cnt becomes equal to k, the
        // second part also have k different
        // characters so break it
        if (cnt == k)
        {
            break;
        }
   
        i++;
    }
     
    
   
    // If the second part has less than
    // k different characters, then
    // print "Not Possible"
    if (cnt < k)
    {
        document.write("Not possible"  + "<br/>");
    }
   
    // Otherwise print both parts
    else
    {
        i = 0;
        while (i <= ans)
        {
            document.write(str[i]);
            i++;
        }
        document.write("" + "<br/>");
   
        while (i < n)
        {
            document.write(str[i]);
            i++;
        }
        document.write("" + "<br/>");
    }
   
    document.write("" + "<br/>");
}
     
    // Driver code
     
    let str = "geeksforgeeks";
    let k = 4;
   
    // Function call
    division_of_string(str.split(''), k);
   
  // This code is contributed by sanjoy_62.
</script>
Output: 
geeks
forgeeks
 
Time Complexity: O(N) where N is the length of given string.
 



My Personal Notes
arrow_drop_up
Previous
Python | Image Registration using OpenCV
Next

Find the number of paths of length K in a directed graph
Recommended Articles
Page :
Count ways to partition a string such that both parts have equal distinct characters
08, Apr 20
Check if both halves of the string have at least one different character
09, Jan 18
Check if both halves of the string have same set of characters
05, Jul 17
Check if both halves of the string have same set of characters in Python
03, Dec 17
Split a string in equal parts such that all parts are palindromes
27, Dec 18
Least number of manipulations needed to ensure two strings have identical characters
23, Aug 17
Count of 3 length strings using given characters containing at least 2 different characters
27, Oct 21
Partition a number into two divisible parts
27, Jan 17
Partition a string into palindromic strings of at least length 2 with every character present in a single string
23, Mar 21
Number of Positions to partition the string such that atleast m characters with same frequency are present in each substring
17, Apr 19
Partition string into two substrings having maximum number of common non-repeating characters
02, Dec 20
Minimize swaps of same-indexed characters to make sum of ASCII value of characters of both the strings odd
10, Feb 21
Count ways to partition a Binary String such that each substring contains exactly two 0s
13, Jan 21
Rearrange the characters of the string such that no two adjacent characters are consecutive English alphabets
25, Jul 19
Minimize swaps of pairs of characters required such that no two adjacent characters in the string are same
09, Jul 21
Count pairs (p, q) such that p occurs in array at least q times and q occurs at least p times
25, Feb 19
Print all positions of a given string having count of smaller characters equal on both sides
25, Oct 20
Split the string into minimum parts such that each part is in the another string
12, Jun 20
Partition given string in such manner that i'th substring is sum of (i-1)'th and (i-2)'th substring
15, Feb 18
Ways to split string such that each partition starts with distinct character
05, Apr 18
Count items common to both the lists but with different prices
17, Jan 18
Find two equal subsequences of maximum length with at least one different index
29, Jan 20
Number of ways to partition a string into two balanced subsequences
15, Nov 18
Number of sub-arrays that have at least one duplicate
15, Nov 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Vivek.Pandit
@Vivek.Pandit
Vote for difficulty
Current difficulty :
Hard





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

Start Your Coding Journey Now!