Related Articles

# 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, str2) modifies strings str1 to “dbbd” and str2 to “abca”
Replacing str2 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 ``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

 ``
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