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

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 frequency
            // 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 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

<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 frequency
        // 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 log N)
Auxiliary Space: O(1) because set and map are storing characters and frequency of characters so it will be using constant space