Skip to content
Related Articles

Related Articles

Improve Article

Minimize replacements or swapping of same indexed characters required to make two given strings palindromic

  • Last Updated : 29 Apr, 2021

Given two strings, str1 and str2 consisting of N lowercase alphabets, the task is to find the minimum count of operations of the following two types to make both the strings palindromic string.

  • Replace any character of the strings to any other character([a – z]).
  • Swap any two characters present at the same index in both the strings.

Examples:

Input: str1 = “abbd”, str2 = “dbca” 
Output:
Explanation: 
Swapping (str1[0], str2[0]) modifies strings str1 to “dbbd” and str2 to “abca” 
Replacing str2[1] to ‘c’ modifies string str2 to “acca”. 
Therefore, after above 2 operations, strings str1 and str2 become palindromic.

Input: str1 = “geeksforgeeks”, str2 = “geeksforgeeks” 
Output: 10 
 

Approach: Follow the steps below to solve the problem:



  • Initialize two variables, say i = 0 and j = 0 to store the index of left pointer and right pointer of both the strings respectively.
  • Initialize a variable, say cntOp to store the count of minimum operations required to make both the strings palindromic string.
  • Traverse both the string and check the following conditions: 
    • If str1[i] == str1[j] and str2[i] != str2[j] then replace the value of str2[i] to str2[j] and increment the value of cntOp by 1.
    • If str1[i] != str1[j] and str2[i] == str2[j] then replace the value of str1[i] to str1[j] and increment the value of cntOp by 1.
    • If str1[i] != str1[j] and str2[i] != str2[j] then check the if the value of (str1[i] == str2[j] and str2[i] == str1[j]) equal to true or not. If found to be true then swap(str1[i], str2[j]) and increment the value of cntOp by 1.
    • Otherwise, replace str1[i] to str1[j], str2[i] to str2[j] and increment the value of cntOp by 2.
  • Finally, print the value of cntOp.

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum operations
// to make both the strings palindromic
int MincntBothPalin(string str1,
                    string str2, int N)
{
 
    // Stores index of
    // the left pointer
    int i = 0;
 
    // Stores index of
    // the right pointer
    int j = N - 1;
 
    // Stores count of minimum operations to
    // make both the strings palindromic
    int cntOp = 0;
 
    while (i < j) {
 
        // if str1[i] equal to str1[j]
        // and str2[i] not equal to str2[j]
        if (str1[i] == str1[j]
            && str2[i] != str2[j]) {
 
            // Update cntOp
            cntOp += 1;
        }
 
        // If str1[i] not equal to str1[j]
        // and str2[i] equal to str2[j]
        else if (str1[i] != str1[j]
                 && str2[i] == str2[j]) {
 
            // Update cntOp
            cntOp += 1;
        }
 
        // If str1[i] is not equal to str1[j]
        // and str2[i] is not equal to str2[j]
        else if (str1[i] != str1[j]
                 && str2[i] != str2[j]) {
 
            // If str1[i] is equal to str2[j]
            // and str2[i] is equal to str1[j]
            if (str1[i] == str2[j]
                && str2[i] == str1[j]) {
 
                // Update cntOp
                cntOp += 1;
            }
            else {
 
                // Update cntOp
                cntOp += 2;
            }
        }
 
        // Update i and j
        i += 1;
        j -= 1;
    }
 
    return cntOp;
}
 
// Driver Code
int main()
{
    string str1 = "dbba";
    string str2 = "abcd";
 
    // Stores length of str1
    int N = str1.length();
    cout << MincntBothPalin(
        str1, str2, N);
}

Java




// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Function to find minimum operations
// to make both the Strings palindromic
static int MincntBothPalin(char[] str1,
                           char[] str2, int N)
{
     
    // Stores index of
    // the left pointer
    int i = 0;
 
    // Stores index of
    // the right pointer
    int j = N - 1;
 
    // Stores count of minimum operations to
    // make both the Strings palindromic
    int cntOp = 0;
 
    while (i < j)
    {
         
        // If str1[i] equal to str1[j]
        // and str2[i] not equal to str2[j]
        if (str1[i] == str1[j] &&
            str2[i] != str2[j])
        {
 
            // Update cntOp
            cntOp += 1;
        }
 
        // If str1[i] not equal to str1[j]
        // and str2[i] equal to str2[j]
        else if (str1[i] != str1[j] &&
                 str2[i] == str2[j])
        {
             
            // Update cntOp
            cntOp += 1;
        }
 
        // If str1[i] is not equal to str1[j]
        // and str2[i] is not equal to str2[j]
        else if (str1[i] != str1[j] &&
                 str2[i] != str2[j])
        {
             
            // If str1[i] is equal to str2[j]
            // and str2[i] is equal to str1[j]
            if (str1[i] == str2[j] &&
                str2[i] == str1[j])
            {
                 
                // Update cntOp
                cntOp += 1;
            }
            else
            {
                 
                // Update cntOp
                cntOp += 2;
            }
        }
 
        // Update i and j
        i += 1;
        j -= 1;
    }
    return cntOp;
}
 
// Driver Code
public static void main(String[] args)
{
    String str1 = "dbba";
    String str2 = "abcd";
 
    // Stores length of str1
    int N = str1.length();
     
    System.out.print(MincntBothPalin(
        str1.toCharArray(), str2.toCharArray(), N));
}
}
 
// This code is contributed by Amit Katiyar

Python3




# Python3 program to implement
# the above approach
 
# Function to find minimum
# operations to make both
# the strings palindromic
def MincntBothPalin(str1,
                    str2, N):
 
    # Stores index of
    # the left pointer
    i = 0
 
    # Stores index of
    # the right pointer
    j = N - 1
 
    # Stores count of minimum
    # operations to make both
    # the strings palindromic
    cntOp = 0
 
    while (i < j):
 
        # if str1[i] equal to
        # str1[j] and str2[i]
        # not equal to str2[j]
        if (str1[i] == str1[j] and
            str2[i] != str2[j]):
 
            # Update cntOp
            cntOp += 1
 
        # If str1[i] not equal
        # to str1[j] and str2[i]
        # equal to str2[j]
        elif (str1[i] != str1[j] and
              str2[i] == str2[j]):
 
            # Update cntOp
            cntOp += 1
 
        # If str1[i] is not equal
        # to str1[j] and str2[i]
        # is not equal to str2[j]
        elif (str1[i] != str1[j] and
              str2[i] != str2[j]):
 
            # If str1[i] is equal to
            # str2[j] and str2[i] is
            # equal to str1[j]
            if (str1[i] == str2[j] and
                str2[i] == str1[j]):
 
                # Update cntOp
                cntOp += 1
 
            else:
 
                # Update cntOp
                cntOp += 2
 
        # Update i and j
        i += 1
        j -= 1
 
    return cntOp
 
# Driver Code
if __name__ == "__main__":
   
    str1 = "dbba"
    str2 = "abcd"
 
    # Stores length of str1
    N = len(str1)
    print(MincntBothPalin(str1,
                          str2, N))
 
# This code is contributed by Chitranayal

C#




// C# program to implement
// the above approach
using System;
class GFG{
 
// Function to find minimum operations
// to make both the strings palindromic
static int MincntBothPalin(string str1,
                           string str2, int N)
{   
  // Stores index of
  // the left pointer
  int i = 0;
 
  // Stores index of
  // the right pointer
  int j = N - 1;
 
  // Stores count of minimum
  // operations to make both
  // the strings palindromic
  int cntOp = 0;
 
  while (i < j)
  {
    // If str1[i] equal to
    // str1[j] and str2[i]
    // not equal to str2[j]
    if (str1[i] == str1[j] &&
        str2[i] != str2[j])
    {
      // Update cntOp
      cntOp += 1;
    }
 
    // If str1[i] not equal
    // to str1[j] and str2[i]
    // equal to str2[j]
    else if (str1[i] != str1[j] &&
             str2[i] == str2[j])
    {
      // Update cntOp
      cntOp += 1;
    }
 
    // If str1[i] is not equal
    // to str1[j] and str2[i]
    // is not equal to str2[j]
    else if (str1[i] != str1[j] &&
             str2[i] != str2[j])
    {
      // If str1[i] is equal
      // to str2[j] and str2[i]
      // is equal to str1[j]
      if (str1[i] == str2[j] &&
          str2[i] == str1[j])
      {
        // Update cntOp
        cntOp += 1;
      }
      else
      {
        // Update cntOp
        cntOp += 2;
      }
    }
 
    // Update i and j
    i += 1;
    j -= 1;
  }
  return cntOp;
}
 
// Driver Code
public static void Main()
{
  string str1 = "dbba";
  string str2 = "abcd";
 
  // Stores length of str1
  int N = str1.Length;
 
  Console.WriteLine(
  MincntBothPalin(str1,
                  str2, N));
}
}
 
// This code is contributed by bgangwar59

Javascript




<script>
 
      // JavaScript program to implement
      // the above approach
 
      // Function to find minimum operations
      // to make both the strings palindromic
      function MincntBothPalin(str1, str2, N)
      {
        // Stores index of
        // the left pointer
        var i = 0;
 
        // Stores index of
        // the right pointer
        var j = N - 1;
 
        // Stores count of minimum operations to
        // make both the strings palindromic
        var cntOp = 0;
 
        while (i < j) {
          // if str1[i] equal to str1[j]
          // and str2[i] not equal to str2[j]
          if (str1[i] === str1[j] &&
          str2[i] !== str2[j]) {
            // Update cntOp
            cntOp += 1;
          }
 
          // If str1[i] not equal to str1[j]
          // and str2[i] equal to str2[j]
          else if (str1[i] !== str1[j] &&
          str2[i] === str2[j]) {
            // Update cntOp
            cntOp += 1;
          }
 
          // If str1[i] is not equal to str1[j]
          // and str2[i] is not equal to str2[j]
          else if (str1[i] !== str1[j] &&
          str2[i] !== str2[j])
          {
            // If str1[i] is equal to str2[j]
            // and str2[i] is equal to str1[j]
            if (str1[i] === str2[j] &&
            str2[i] === str1[j]) {
              // Update cntOp
              cntOp += 1;
            } else {
              // Update cntOp
              cntOp += 2;
            }
          }
 
          // Update i and j
          i += 1;
          j -= 1;
        }
 
        return cntOp;
      }
 
      // Driver Code
      var str1 = "dbba";
      var str2 = "abcd";
 
      // Stores length of str1
      var N = str1.length;
      document.write(MincntBothPalin(str1, str2, N));
       
    </script>
Output: 
2

 

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :