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

• Last Updated : 30 Jan, 2023

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``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 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 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 frequency``            ``// characters in the string S``            ``int` `count1 = ``0``, count2 = ``0``;` `            ``for` `(Map.Entry 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 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 frequency``        ``# 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`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `MainClass {``  ``// Utility function to check if string``  ``// S can be made palindromic or not``  ``public` `static` `bool` `CanBecomePalindromeUtil(``string` `S,``                                             ``string` `B)``  ``{``    ``// Stores the number of distinct``    ``// characters present in string S``    ``HashSet<``char``> ``set` `= ``new` `HashSet<``char``>();` `    ``// Traverse the characters of string S``    ``for` `(``int` `i = 0; i < S.Length; i++) {``      ``// Insert current character in S``      ``set``.Add(S[i]);``    ``}` `    ``// Count frequency of each``    ``// character of string S``    ``Dictionary<``char``, ``int``> map``      ``= ``new` `Dictionary<``char``, ``int``>();` `    ``// Traverse the characters of string S``    ``for` `(``int` `i = 0; i < S.Length; i++) {``      ``int` `k = 0;``      ``if` `(map.ContainsKey(S[i])) {``        ``k = map[S[i]];``      ``}``      ``map[S[i]] = k + 1;``    ``}` `    ``bool` `flag = ``false``;` `    ``// Check for the odd length string``    ``if` `(S.Length % 2 == 1) {``      ``// Stores the count of``      ``// even and odd frequency``      ``// characters in the string S``      ``int` `count1 = 0, count2 = 0;` `      ``foreach``(``var` `e ``in` `map)``      ``{``        ``if` `(e.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 == ``set``.Count - 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;` `      ``foreach``(``var` `e ``in` `map)``      ``{``        ``if` `(e.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 == ``set``.Count && 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[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``  ``static` `void` `CanBecomePalindrome(``string` `S, ``string` `B)``  ``{``    ``if` `(CanBecomePalindromeUtil(S, B))``      ``Console.WriteLine(``"Yes"``);``    ``else``      ``Console.WriteLine(``"Np"``);``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``string` `S = ``"ACABB"``;``    ``string` `B = ``"00010"``;``    ``CanBecomePalindrome(S, B);``  ``}``}` `// This code is contributed by phasing17.`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(N log N)
Auxiliary Space: O(1) because set and map are storing characters and frequency of characters so it will be using constant space

My Personal Notes arrow_drop_up