Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String

Last Updated : 21 Nov, 2021

Given a string S and a binary string B, both of length N, the task is to check if the given string S can be made palindromic by repeatedly swapping characters at any pair of indices consisting of unequal characters in the string B.

Examples:

Input: S = “BAA”, B = “100”
Output: Yes
Explanation:
Swapping S[0] and S[1] modifies S to “ABA” and B to “010”.
Input: S = “ACABB”, B = “00000”
Output: No

Approach: Follow the below steps to solve this problem:

Check if string S can be rearranged to form a palindromic string or not. If found to be false, then print “No”.
Otherwise, if the string S is a palindrome, then print “Yes”.
If the count of 0s and 1s is at least 1, then there always exists a way to swap characters to make the given string S palindromic. Therefore, print “Yes”. Otherwise, print “No”.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Utility function to check if string
// S can be made palindromic or not
bool canBecomePalindromeUtil(string S, string B)
{
     
    // Stores the number of distinct
    // characters present in string S
    unordered_set<char> set;
 
    // Traverse the characters of string S
    for(int i = 0; i < S.size(); i++)
    {
         
        // Insert current character in S
        set.insert(S[i]);
    }
 
    // Count frequency of each
    // character of string S
    map<char, int> map;
 
    // Traverse the characters of string S
    for(int i = 0; i < S.length(); i++)
    {
        map[S[i]] += 1;
    }
 
    bool flag = false;
 
    // Check for the odd length string
    if (S.size() % 2 == 1)
    {
         
        // Stores the count of
        // even and odd frequent
        // characters in the string S
        int count1 = 0, count2 = 0;
 
        for(auto e : map)
        {
            if (e.second % 2 == 1)
            {
                 
                // Update the count of
                // odd frequent characters
                count2++;
            }
            else
            {
                 
                // Update the count of
                // even frequent characters
                count1++;
            }
        }
 
        // If the conditions satisfies
        if (count1 == set.size() - 1 && count2 == 1)
        {
            flag = true;
        }
    }
 
    // Check for even length string
    else
    {
         
        // Stores the frequency of
        // even and odd characters
        // in the string S
        int count1 = 0, count2 = 0;
 
        for(auto e : map)
        {
            if (e.second % 2 == 1)
            {
                 
                // Update the count of
                // odd frequent characters
                count2++;
            }
            else
            {
 
                // Update the count of
                // even frequent characters
                count1++;
            }
        }
 
        // If the condition satisfies
        if (count1 == set.size() && count2 == 0)
        {
            flag = true;
        }
    }
 
    // If a palindromic string
    // cannot be formed
    if (!flag)
    {
        return false;
    }
 
    else
    {
 
        // Check if there is
        // atleast one '1' and '0'
        int count1 = 0, count0 = 0;
        for(int i = 0; i < B.size(); i++)
        {
 
            // If current character is '1'
            if (B[i] == '1')
            {
                count1++;
            }
            else
            {
                count0++;
            }
        }
 
        // If atleast one '1' and '0' is present
        if (count1 >= 1 && count0 >= 1)
        {
            return true;
        }
 
        else
        {
            return false;
        }
    }
}
 
// Function to determine whether
// string S can be converted to
// a palindromic string or not
void canBecomePalindrome(string S, string B)
{
    if (canBecomePalindromeUtil(S, B))
        cout << "Yes";
    else
        cout << "No";
}
 
// Driver code
int main()
{
    string S = "ACABB";
    string B = "00010";
    canBecomePalindrome(S, B);
 
    return 0;
}
 
// This code is contributed by Kingash

Java

// Java program for the above approach
 
import java.io.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
 
class GFG {
 
    // Utility function to check if string
    // S can be made palindromic or not
    public static boolean
    canBecomePalindromeUtil(String S,
                            String B)
    {
        // Stores the number of distinct
        // characters present in string S
        HashSet<Character> set = new HashSet<>();
 
        // Traverse the characters of string S
        for (int i = 0; i < S.length(); i++) {
 
            // Insert current character in S
            set.add(S.charAt(i));
        }
 
        // Count frequency of each
        // character of string S
        HashMap<Character, Integer> map
            = new HashMap<>();
 
        // Traverse the characters of string S
        for (int i = 0; i < S.length(); i++) {
            Integer k = map.get(S.charAt(i));
            map.put(S.charAt(i),
                    (k == null) ? 1 : k + 1);
        }
 
        boolean flag = false;
 
        // Check for the odd length string
        if (S.length() % 2 == 1) {
 
            // Stores the count of
            // even and odd frequenct
            // characters in the string S
            int count1 = 0, count2 = 0;
 
            for (Map.Entry<Character, Integer> e :
                 map.entrySet()) {
 
                if (e.getValue() % 2 == 1) {
 
                    // Update the count of
                    // odd frequent characters
                    count2++;
                }
                else {
 
                    // Update the count of
                    // even frequent characters
                    count1++;
                }
            }
 
            // If the conditions satisfies
            if (count1 == set.size() - 1
                && count2 == 1) {
                flag = true;
            }
        }
 
        // Check for even length string
        else {
 
            // Stores the frequency of
            // even and odd characters
            // in the string S
            int count1 = 0, count2 = 0;
 
            for (Map.Entry<Character, Integer> e :
                 map.entrySet()) {
 
                if (e.getValue() % 2 == 1) {
 
                    // Update the count of
                    // odd frequent characters
                    count2++;
                }
                else {
 
                    // Update the count of
                    // even frequent characters
                    count1++;
                }
            }
 
            // If the condition satisfies
            if (count1 == set.size()
                && count2 == 0) {
                flag = true;
            }
        }
 
        // If a palindromic string
        // cannot be formed
        if (!flag) {
            return false;
        }
 
        else {
 
            // Check if there is
            // atleast one '1' and '0'
            int count1 = 0, count0 = 0;
            for (int i = 0;
                 i < B.length(); i++) {
 
                // If current character is '1'
                if (B.charAt(i) == '1') {
                    count1++;
                }
                else {
                    count0++;
                }
            }
 
            // If atleast one '1' and '0' is present
            if (count1 >= 1 && count0 >= 1) {
                return true;
            }
 
            else {
                return false;
            }
        }
    }
 
    // Function to determine whether
    // string S can be converted to
    // a palindromic string or not
    public static void
    canBecomePalindrome(String S,
                        String B)
    {
        if (canBecomePalindromeUtil(S, B))
            System.out.print("Yes");
        else
            System.out.print("No");
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        String S = "ACABB";
        String B = "00010";
        canBecomePalindrome(S, B);
    }
}

Python3

# Python3 program for the above approach
 
# Utility function to check if string
# S can be made palindromic or not
def canBecomePalindromeUtil(S, B):
     
    # Stores the number of distinct
    # characters present in string S
    s = set(S)
 
    # Count frequency of each
    # character of string S
    map = {}
 
    # Traverse the characters of string S
    for i in range(len(S)):
        if S[i] in map:
            map[S[i]] += 1
        else:
            map[S[i]] = 1
 
    flag = False
 
    # Check for the odd length string
    if (len(S) % 2 == 1):
         
        # Stores the count of
        # even and odd frequenct
        # characters in the string S
        count1 = 0
        count2 = 0
 
        for e in map:
            if (map[e] % 2 == 1):
                 
                # Update the count of
                # odd frequent characters
                count2 += 1
                 
            else:
                 
                # Update the count of
                # even frequent characters
                count1 += 1
 
        # If the conditions satisfies
        if (count1 == len(s) - 1 and
            count2 == 1):
            flag = True
 
    # Check for even length string
    else:
         
        # Stores the frequency of
        # even and odd characters
        # in the string S
        count1 = 0
        count2 = 0
 
        for e in map:
            if (map[e] % 2 == 1):
                 
                # Update the count of
                # odd frequent characters
                count2 += 1
                 
            else:
 
                # Update the count of
                # even frequent characters
                count1 += 1
 
        # If the condition satisfies
        if (count1 == len(s) and count2 == 0):
            flag = True
 
    # If a palindromic string
    # cannot be formed
    if (not flag):
        return False
 
    else:
 
        # Check if there is
        # atleast one '1' and '0'
        count1 = 0
        count0 = 0
        for i in range(len(B)):
 
            # If current character is '1'
            if (B[i] == '1'):
                count1 += 1
            else:
                count0 += 1
 
        # If atleast one '1' and '0' is present
        if (count1 >= 1 and count0 >= 1):
            return True
        else:
            return False
       
# Function to determine whether
# string S can be converted to
# a palindromic string or not
def canBecomePalindrome(S, B):
 
    if (canBecomePalindromeUtil(S, B)):
        print("Yes")
    else:
        print("No")
 
# Driver code
if __name__ == "__main__":
 
    S = "ACABB"
    B = "00010"
     
    canBecomePalindrome(S, B)
 
# This code is contributed by AnkThon

Javascript

<script>
 
// Javascript program for the above approach
 
// Utility function to check if string
// S can be made palindromic or not
function canBecomePalindromeUtil(S, B)
{
     
    // Stores the number of distinct
    // characters present in string S
    var st = new Set()
    var i;
     
    // Traverse the characters of string S
    for(i = 0; i < S.length; i++)
    {
         
        // Insert current character in S
        st.add(S[i]);
    }
 
    // Count frequency of each
    // character of string S
    var mp = new Map();
 
    // Traverse the characters of string S
    for(i = 0; i < S.length; i++)
    {
        if (mp.has(S[i]))
            mp.set(S[i], mp.get(S[i]))
        else
            mp.set(S[i], 1);
    }
 
    var flag = false;
 
    // Check for the odd length string
    if (S.length % 2 == 1)
    {
         
        // Stores the count of
        // even and odd frequenct
        // characters in the string S
        var count1 = 0, count2 = 0;
        for(const [key, value] of Object.entries(mp))
        {
            if (value % 2 == 1)
            {
                 
                // Update the count of
                // odd frequent characters
                count2++;
            }
            else
            {
                 
                // Update the count of
                // even frequent characters
                count1++;
            }
         }
 
        // If the conditions satisfies
        if (count1 == st.size - 1 && count2 == 1)
        {
            flag = true;
        }
    }
 
    // Check for even length string
    else
    {
         
        // Stores the frequency of
        // even and odd characters
        // in the string S
        var count1 = 0, count2 = 0;
 
        for (const [key, value] of Object.entries(mp))
        {
            if (value % 2 == 1)
            {
                 
                // Update the count of
                // odd frequent characters
                count2++;
            }
            else
            {
 
                // Update the count of
                // even frequent characters
                count1++;
            }
        }
 
        // If the condition satisfies
        if (count1 == st.size && count2 == 0)
        {
            flag = true;
        }
    }
 
    // If a palindromic string
    // cannot be formed
    if (!flag)
    {
        return false;
    }
 
    else
    {
         
        // Check if there is
        // atleast one '1' and '0'
        var count1 = 0, count0 = 0;
        for(i = 0; i < B.length; i++)
        {
 
            // If current character is '1'
            if (B[i] == '1')
            {
                count1++;
            }
            else
            {
                count0++;
            }
        }
 
        // If atleast one '1' and '0' is present
        if (count1 >= 1 && count0 >= 1)
        {
            return true;
        }
 
        else
        {
            return false;
        }
    }
}
 
// Function to determine whether
// string S can be converted to
// a palindromic string or not
function canBecomePalindrome(S, B)
{
    if (canBecomePalindromeUtil(S, B))
        document.write("No");
    else
        document.write("Yes");
}
 
// Driver code
var S = "ACABB";
var B = "00010";
 
canBecomePalindrome(S, B);
     
// This code is contributed by SURENDRA_GANGWAR
 
</script>

Output:

Yes

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

My Personal Notes

Related Articles

Table of Contents

Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String

C++

Java

Python3

Javascript

Start Your Coding Journey Now!