Skip to content
Related Articles

Related Articles

Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
  • Last Updated : 05 Apr, 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:



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 frequenct
        // 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
Output: 
Yes
 
Time Complexity: O(N)
Auxiliary Space: O(N)
 
My Personal Notes
arrow_drop_up
Previous
Convert an array into another by repeatedly removing the last element and placing it at any arbitrary index
Next

Minimize length of a string by removing suffixes and prefixes of same characters
Recommended Articles
Page :
Check if two binary strings can be made equal by swapping pairs of unequal characters
20, Jan 21
Check if two strings can be made equal by swapping pairs of adjacent characters
03, Feb 21
Check if a string can be made equal to another string by swapping or replacement of characters
24, Jan 21
Count N-length arrays made from first M natural numbers whose subarrays can be made palindromic by replacing less than half of its elements
16, Dec 20
Maximize given integer by swapping pairs of unequal bits
29, Jan 21
Check if given strings can be made same by swapping two characters of same or different strings
07, Dec 20
Check if two binary strings can be made equal by swapping 1s occurring before 0s
18, Jan 21
Check if permutation of a given string can be made palindromic by removing at most K characters
25, Oct 20
Longest Substring that can be made a palindrome by swapping of characters
25, Dec 20
Count new pairs of strings that can be obtained by swapping first characters of pairs of strings from given array
14, Apr 21
Check if two strings can be made equal by swapping one character among each other
20, Nov 19
Check if a palindromic string can be obtained by concatenating substrings split from same indices of two given strings
16, Oct 20
Minimize count of unequal elements at corresponding indices between given arrays
26, Aug 20
Check if any subarray can be made palindromic by replacing less than half of its elements
02, Dec 20
Check whether the number can be made palindromic after adding K
04, Apr 20
Make the string lexicographically smallest and non palindromic by swapping of adjacent pair of characters
09, Sep 20
Count of Palindromic Strings possible by swapping of a pair of Characters
31, Jul 20
Minimize replacements or swapping of same indexed characters required to make two given strings palindromic
03, Nov 20
Check if a string can be converted to another by swapping of adjacent characters of given type
01, Sep 20
Check if characters of a string can be made non-decreasing by replacing '?'s
17, Feb 21
Check if all characters of a string can be made equal by increments or decrements
05, May 21
Minimum replacements to make adjacent characters unequal in a ternary string | Set-2
08, Feb 19
Minimum replacements to make adjacent characters unequal in a ternary string
24, Jan 19
Minimum replacements in a string to make adjacent characters unequal
22, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
aditya7409
@aditya7409
Vote for difficulty





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