Skip to content
Related Articles

Related Articles

Improve Article
Partition a string into palindromic strings of at least length 2 with every character present in a single string
  • Last Updated : 22 Apr, 2021

Given a string S consisting of N lowercase alphabets, the task is to check if all the strings of at least length 2 formed by selecting every character of the string S only once are palindromic or not. If found to be true, then print “Yes”. Otherwise, print “No”.

Examples:

Input: S = “abbbaddzcz”
Output: Yes
Explanation: The palindromic strings of length greater than 1 are { “aa”, “bbb”, “dd”, “zcz”} and all the characters in the given string is used only once. Therefore, print “Yes”.

Input: S = “abcd”
Output: No

Approach: The idea is to break the string into a palindromic strings of even length, and if there exists a character having frequency 1, then pair it with a palindromic string of even length. Follow the steps below to solve the problem:



  • Initialize an array, say freq[], of size 26, to store the frequency of each character present in the string.
  • Iterate over the characters of the given string S and update the frequency of each character in the array freq[].
  • Initialize two variables, say O and E, to store the count of unique characters and characters having even frequencies respectively.
  • Traverse the array freq[] and if freq[i] is equal to 1, then increment O by 1. Otherwise, increment E by 1.
  • Check if E ≥ O, then print “Yes”. Otherwise, perform the following steps:
    • Update O to O – E, to store the remaining unique characters after pairing.
    • Traverse the array freq[] and if the value of O is at most 0, then break out of the loop. Otherwise, update O to O – (freq[i]/2) and then increment O by 1.
  • After completing the above steps, if the value of O ≤ 0, then print “Yes”. Otherwise, print “No”.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <iostream>
using namespace std;
 
// Function to check if  a string can be
// split into palindromic strings of at
// least length 2 by including every
// character exactly once
void checkPalindrome(string& s)
{
    // Stores the frequency
    // of each character
    int a[26] = { 0 };
 
    // Store the frequency of
    // characters with frequencies
    // 1 and even respectively
    int o = 0, e = 0;
 
    // Traverse the string s
    for (int i = 0; s[i] != '\0'; i++)
        a[(int)s[i] - 97]++;
 
    // Iterate over all the characters
    for (int i = 0; i < 26; i++) {
 
        // If the frequency is 1
        if (a[i] == 1)
            o++;
 
        // If frequency is even
        else if (a[i] % 2 == 0
                 and a[i] != 0)
            e += (a[i] / 2);
    }
 
    // Print the result
    if (e >= o)
        cout << "Yes";
 
    else {
 
        // Stores the number of characters
        // with frequency equal to 1 that
        // are not part of a palindromic string
        o = o - e;
 
        // Iterate over all the characters
        for (int i = 0; i < 26; i++) {
 
            // If o becomes less than 0,
            // then break out of the loop
            if (o <= 0)
                break;
 
            // If frequency of the current
            // character is > 2 and is odd
            if (o > 0
                and a[i] % 2 == 1
                and a[i] > 2) {
 
                int k = o;
 
                // Update the value of o
                o = o - a[i] / 2;
 
                // If a single character
                // is still remaining
                if (o > 0 or 2 * k + 1 == a[i]) {
 
                    // Increment o by 1
                    o++;
 
                    // Set a[i] to 1
                    a[i] = 1;
                }
            }
        }
 
        // Print the result
        if (o <= 0)
            cout << "Yes";
        else
            cout << "No";
    }
}
 
// Driver Code
int main()
{
    string S = "abbbaddzcz";
    checkPalindrome(S);
 
    return 0;
}

Java




// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG{
 
// Function to check if  a string can be
// split into palindromic strings of at
// least length 2 by including every
// character exactly once
static void checkPalindrome(String s)
{
     
    // Stores the frequency
    // of each character
    int a[] = new int[26];
 
    // Store the frequency of
    // characters with frequencies
    // 1 and even respectively
    int o = 0, e = 0;
 
    // Traverse the string s
    for(int i = 0; i < s.length(); i++)
        a[s.charAt(i) - 'a']++;
 
    // Iterate over all the characters
    for(int i = 0; i < 26; i++)
    {
         
        // If the frequency is 1
        if (a[i] == 1)
            o++;
 
        // If frequency is even
        else if (a[i] % 2 == 0 && a[i] != 0)
            e += (a[i] / 2);
    }
 
    // Print the result
    if (e >= o)
        System.out.println("Yes");
 
    else
    {
         
        // Stores the number of characters
        // with frequency equal to 1 that
        // are not part of a palindromic string
        o = o - e;
 
        // Iterate over all the characters
        for(int i = 0; i < 26; i++)
        {
             
            // If o becomes less than 0,
            // then break out of the loop
            if (o <= 0)
                break;
 
            // If frequency of the current
            // character is > 2 and is odd
            if (o > 0 && a[i] % 2 == 1 && a[i] > 2)
            {
                int k = o;
 
                // Update the value of o
                o = o - a[i] / 2;
 
                // If a single character
                // is still remaining
                if (o > 0 || 2 * k + 1 == a[i])
                {
                     
                    // Increment o by 1
                    o++;
 
                    // Set a[i] to 1
                    a[i] = 1;
                }
            }
        }
 
        // Print the result
        if (o <= 0)
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}
 
// Driver Code
public static void main(String[] args)
{
    String S = "abbbaddzcz";
     
    checkPalindrome(S);
}
}
 
// This code is contributed by Kingash

Python3




# Python3 program for the above approach
 
# Function to check if  a string can be
# split into palindromic strings of at
# least length 2 by including every
# character exactly once
def checkPalindrome(s):
     
    # Stores the frequency
    # of each character
    a = [0] * 26
 
    # Store the frequency of
    # characters with frequencies
    # 1 and even respectively
    o, e = 0, 0
 
    # Traverse the string s
    for i in s:
        a[ord(i) - 97] += 1
 
    # Iterate over all the characters
    for i in range(26):
         
        # If the frequency is 1
        if (a[i] == 1):
            o += 1
 
        # If frequency is even
        elif (a[i] % 2 == 0 and a[i] != 0):
            e += (a[i] // 2)
 
    # Print the result
    if (e >= o):
        print("Yes")
    else:
         
        # Stores the number of characters
        # with frequency equal to 1 that
        # are not part of a palindromic string
        o = o - e
 
        # Iterate over all the characters
        for i in range(26):
             
            # If o becomes less than 0,
            # then break out of the loop
            if (o <= 0):
                break
 
            # If frequency of the current
            # character is > 2 and is odd
            if (o > 0 and a[i] % 2 == 1 and a[i] > 2):
                k = o
                 
                # Update the value of o
                o = o - a[i] // 2
 
                # If a single character
                # is still remaining
                if (o > 0 or 2 * k + 1 == a[i]):
 
                    # Increment o by 1
                    o += 1
 
                    # Set a[i] to 1
                    a[i] = 1
 
        # Print the result
        if (o <= 0):
            print("Yes")
        else:
            print("No")
             
# Driver Code
if __name__ == '__main__':
     
    S = "abbbaddzcz"
     
    checkPalindrome(S)
 
# This code is contributed by mohit kumar 29

C#




// C# program for the above approach
using System;
 
class GFG{
     
// Function to check if  a string can be
// split into palindromic strings of at
// least length 2 by including every
// character exactly once
static void checkPalindrome(string s)
{
     
    // Stores the frequency
    // of each character
    int[] a = new int[26];
 
    // Store the frequency of
    // characters with frequencies
    // 1 and even respectively
    int o = 0, e = 0;
 
    // Traverse the string s
    for(int i = 0; i < s.Length; i++)
        a[s[i] - 'a']++;
 
    // Iterate over all the characters
    for(int i = 0; i < 26; i++)
    {
         
        // If the frequency is 1
        if (a[i] == 1)
            o++;
 
        // If frequency is even
        else if (a[i] % 2 == 0 && a[i] != 0)
            e += (a[i] / 2);
    }
 
    // Print the result
    if (e >= o)
        Console.WriteLine("Yes");
 
    else
    {
         
        // Stores the number of characters
        // with frequency equal to 1 that
        // are not part of a palindromic string
        o = o - e;
 
        // Iterate over all the characters
        for(int i = 0; i < 26; i++)
        {
             
            // If o becomes less than 0,
            // then break out of the loop
            if (o <= 0)
                break;
 
            // If frequency of the current
            // character is > 2 and is odd
            if (o > 0 && a[i] % 2 == 1 && a[i] > 2)
            {
                int k = o;
 
                // Update the value of o
                o = o - a[i] / 2;
 
                // If a single character
                // is still remaining
                if (o > 0 || 2 * k + 1 == a[i])
                {
                     
                    // Increment o by 1
                    o++;
 
                    // Set a[i] to 1
                    a[i] = 1;
                }
            }
        }
 
        // Print the result
        if (o <= 0)
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
 
// Driver code
static void Main()
{
    string S = "abbbaddzcz";
     
    checkPalindrome(S);
}
}
 
// This code is contributed by sanjoy_62

Javascript




<script>
 
        // Javascript program for the above approach
 
        // Function to check if  a string can be
        // split into palindromic strings of at
        // least length 2 by including every
        // character exactly once
        function checkPalindrome( s )
        {
            // Stores the frequency
            // of each character
            let a = [0]
 
            // Store the frequency of
            // characters with frequencies
            // 1 and even respectively
            let o = 0, e = 0;
 
            // Traverse the string s
            for (let i = 0; i<s.length; i++)
                a[s.charCodeAt(i) - 97]++;
 
            // Iterate over all the characters
            for (let i = 0; i < 26; i++) {
 
                // If the frequency is 1
                if (a[i] == 1)
                    o++;
 
                // If frequency is even
                else if (a[i] % 2 == 0 && a[i] != 0)
                    e += (a[i] / 2);
            }
 
            // Print the result
            if (e >= o)
                document.write("Yes")
 
            else {
 
                // Stores the number of characters
                // with frequency equal to 1 that
                // are not part of a palindromic string
                o = o - e;
 
                // Iterate over all the characters
                for (let i = 0; i < 26; i++)
                {
 
                    // If o becomes less than 0,
                    // then break out of the loop
                    if (o <= 0)
                        break;
 
                    // If frequency of the current
                    // character is > 2 and is odd
                    if (o > 0 && a[i] % 2 == 1 && a[i] > 2)
                    {
 
                        let k = o;
 
                        // Update the value of o
                        o = o - a[i] / 2;
 
                        // If a single character
                        // is still remaining
                        if (o > 0 || 2 * k + 1 == a[i])
                        {
 
                            // Increment o by 1
                            o++;
 
                            // Set a[i] to 1
                            a[i] = 1;
                        }
                    }
                }
 
                // Print the result
                if (o <= 0)
                document.write("Yes")
                else
                document.write("No")
            }
        }
 
        // Driver Code
         
        let S = "abbbaddzcz";
        checkPalindrome(S);
 
        // This code is contributed by Hritik
         
    </script>
Output: 
Yes

 

Time Complexity: O(N)
Auxiliary Space: O(1)

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 industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :