Wednesday, November 20, 2024
Google search engine
HomeData Modelling & AIFind if string is K-Palindrome or not using all characters exactly once

Find if string is K-Palindrome or not using all characters exactly once

Given a string str and an integer K, the task is to check if it is possible to make the string K palindromes using all the characters of the string exactly once.
Examples: 
 

Input: str = “poor”, K = 3 
Output: Yes 
One way of getting 3 palindromes is: oo, p, r
Input: str = “fun”, K = 5 
Output: No 
2 palindromes can’t be constructed using 3 distinct letters. Hence not possible. 
 

Approach: 
 

  1. If the size of the string is less than k, getting k palindromes is not possible.
  2. If the size of the string is equal to k, getting k palindromes is always possible. We give 1 character to each of k strings and all of them are palindromes as a string of length 1 is always a palindrome.
  3. If the size of the string is greater than k then some strings might have more than 1 character. 
    • Create a hashmap to store the frequency of every character as the characters having even number of occurrences can be distributed in groups of 2.
    • Check if the number of characters having an odd number of occurrences is less than or equal to k, we can say that k palindromes can always be generated else no.

Below is the implementation of the above approach: 
 

C++




// C++ program to find if string is K-Palindrome
// or not using all characters exactly once
 
#include <bits/stdc++.h>
using namespace std;
 
void iskPalindromesPossible(string s, int k)
{
    // when size of string is less than k
    if (s.size() < k) {
        cout << "Not Possible" << endl;
        return;
    }
 
    // when size of string is equal to k
    if (s.size() == k) {
        cout << "Possible" << endl;
        return;
    }
 
    // when size of string is greater than k
 
    // to store the frequencies of the characters
    map<char, int> freq;
    for (int i = 0; i < s.size(); i++)
        freq[s[i]]++;
 
    // to store the count of characters
    // whose number of occurrences is odd.
    int count = 0;
 
    // iterating over the map
    for (auto it : freq) {
        if (it.second % 2 == 1)
            count++;
    }
    if (count > k)
        cout << "No" << endl;
    else
        cout << "Yes" << endl;
}
 
// Driver code
int main()
{
 
    string str = "poor";
    int K = 3;
    iskPalindromesPossible(str, K);
 
    str = "neveropen";
    K = 10;
    iskPalindromesPossible(str, K);
 
    return 0;
}


Java




// Java program to find if String
// is K-Palindrome or not using
// all characters exactly once
import java.util.*;
 
class GFG{
 
static void iskPalindromesPossible(String s,
                                   int k)
{
     
    // When size of String is less than k
    if (s.length() < k)
    {
        System.out.print("Not Possible" + "\n");
        return;
    }
 
    // When size of String is equal to k
    if (s.length() == k)
    {
        System.out.print("Possible" + "\n");
        return;
    }
     
    // When size of String is greater than k
    // to store the frequencies of the characters
    HashMap<Character,
            Integer> freq = new HashMap<Character,
                                        Integer>();
    for(int i = 0; i < s.length(); i++)
       if(freq.containsKey(s.charAt(i)))
       {
           freq.put(s.charAt(i),
           freq.get(s.charAt(i)) + 1);
       }
       else
       {
           freq.put(s.charAt(i), 1);
       }
 
    // To store the count of characters
    // whose number of occurrences is odd.
    int count = 0;
 
    // Iterating over the map
    for(Map.Entry<Character,
                  Integer> it : freq.entrySet())
    {
       if (it.getValue() % 2 == 1)
           count++;
    }
     
    if (count > k)
        System.out.print("No" + "\n");
    else
        System.out.print("Yes" + "\n");
}
 
// Driver code
public static void main(String[] args)
{
    String str = "poor";
    int K = 3;
    iskPalindromesPossible(str, K);
 
    str = "neveropen";
    K = 10;
    iskPalindromesPossible(str, K);
}
}
 
// This code is contributed by sapnasingh4991


Python3




# Find if string is K-Palindrome or not using all characters exactly once
# Python 3 program to find if string is K-Palindrome
# or not using all characters exactly once
 
def iskPalindromesPossible(s, k):
 
    # when size of string is less than k
    if (len(s)<k):
        print("Not Possible")
        return
 
    # when size of string is equal to k
    if (len(s) == k):
        print("Possible")
        return
 
    # when size of string is greater than k
 
    # to store the frequencies of the characters
    freq = dict.fromkeys(s,0)
    for i in range(len(s)):
        freq[s[i]] += 1
 
    #to store the count of characters
    # whose number of occurrences is odd.
    count = 0
 
    # iterating over the map
    for value in freq.values():
        if (value % 2 == 1):
            count += 1
    if (count > k):
        print("No")
    else:
        print("Yes")
 
# Driver code
if __name__ == '__main__':
    str1 = "poor"
    K = 3
    iskPalindromesPossible(str1, K)
 
    str = "neveropen"
    K = 10
    iskPalindromesPossible(str, K)
 
# This code is contributed by Surendra_Gangwar


C#




// C# program to find if String
// is K-Palindrome or not using
// all characters exactly once
using System;
using System.Collections.Generic;
 
class GFG{
 
static void iskPalindromesPossible(String s,
                                   int k)
{
     
    // When size of String is less than k
    if (s.Length < k)
    {
        Console.Write("Not Possible" + "\n");
        return;
    }
 
    // When size of String is equal to k
    if (s.Length == k)
    {
        Console.Write("Possible" + "\n");
        return;
    }
     
    // When size of String is greater than k
    // to store the frequencies of the characters
    Dictionary<int,
               int> freq = new Dictionary<int,
                                          int>();
    for(int i = 0; i < s.Length; i++)
        if(freq.ContainsKey(s[i]))
        {
            freq[s[i]] = freq[s[i]] + 1;
        }
        else
        {
            freq.Add(s[i], 1);
        }
 
    // To store the count of characters
    // whose number of occurrences is odd.
    int count = 0;
 
    // Iterating over the map
    foreach(KeyValuePair<int, int> it in freq)
    {
        if (it.Value % 2 == 1)
            count++;
    }
     
    if (count > k)
        Console.Write("No" + "\n");
    else
        Console.Write("Yes" + "\n");
}
 
// Driver code
public static void Main(String[] args)
{
    String str = "poor";
    int K = 3;
    iskPalindromesPossible(str, K);
 
    str = "neveropen";
    K = 10;
    iskPalindromesPossible(str, K);
}
}
 
// This code is contributed by Princi Singh


Javascript




<Script>
 
// Find if string is K-Palindrome or not using all characters exactly once
// JavaScript program to find if string is K-Palindrome
// or not using all characters exactly once
function iskPalindromesPossible(s, k)
{
 
    // when size of string is less than k
    if (s.length < k)
    {
        document.write("Not Possible","</br>")
        return
    }
 
    // when size of string is equal to k
    if (s.length == k){
        document.write("Possible","</br>")
        return
    }
 
    // when size of string is greater than k
 
    // to store the frequencies of the characters
    let freq = new Map()
    for(let i = 0; i < s.length; i++)
    {
        if(freq.has(s[i])){
            freq.set(s[i],freq.get(s[i])+1);
        }
        freq.set(s[i],1);
    }
    // to store the count of characters
    // whose number of occurrences is odd.
    let count = 0
 
    // iterating over the map
    for(let [key,value] of freq){
        if (value % 2 == 1)
            count += 1
    }
    if (count > k)
        document.write("No","</br>")
    else
        document.write("Yes","</br>")
}
 
// Driver code
 
let str1 = "poor"
let K = 3
iskPalindromesPossible(str1, K)
 
let str = "neveropen"
K = 10
iskPalindromesPossible(str, K)
 
// This code is contributed by shinjanpatra
 
</script>


Output: 

Yes
Yes

 

Time Complexity: O(n), where n is the length of the given string.
Auxiliary Space: O(26) ? O(1), no extra space is required, so it is a constant.

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!

RELATED ARTICLES

Most Popular

Recent Comments