Palindrome by swapping only one character

30 May, 2022
Given a string, the task is to check if the string can be made palindrome by swapping a character only once. [NOTE: only one swap and only one character should be swapped with another character]Examples:  
Input : bbg
Output : true
Explanation: Swap b(1st index) with g.

Input : bdababd
Output : true
Explanation: Swap b(0th index) with d(last index) or
             Swap d(1st index) with b(second index)

Input : gcagac
Output : false
 
Approach:  
This algorithm was based on a thorough analysis of the behavior and possibility of the forming string palindrome. By this analysis, I got the following conclusions : 1. Firstly, we will be finding the differences in the string that actually prevents it from being a palindrome. .....a) To do this, We will start from both the ends and comparing one element from each end at a time, whenever it does match we store the values in a separate array as along with this we keep a count on the number of unmatched items.   2. If the number of unmatched items is more than 2, it is never possible to make it a palindrome string by swapping only one character.   3. If (number of unmatched items = 2) – it is possible to make the string palindrome if the characters present in first unmatched set are same as the characters present in second unmatched set. (For example : try this out “bdababd”).   4. If (number of unmatched items = 1) .....a) if (length of string is even) – it is not possible to make a palindrome string out of this. .....b) if (length of string is odd) – it is possible to make a palindrome string out of this if one of the unmatched character matches with the middle character.   5. If (number of unmatched items = 0) – palindrome is possible if we swap the position of any same characters.  
 
C++
Java
Python3
C#
Javascript
// C++ program palindrome by swapping// only one character#include <bits/stdc++.h>using namespace std; bool isPalindromePossible(string input){    int len = input.length();     // counts the number of differences    // which prevents the string from    // being palindrome.    int diffCount = 0, i;     // keeps a record of the characters    // that prevents the string from    // being palindrome.    char diff[2][2];     // loops from the start of a string    // till the midpoint of the string    for (i = 0; i < len / 2; i++)    {         // difference is encountered preventing        // the string from being palindrome        if (input[i] != input[len - i - 1])        {                         // 3rd differences encountered and            // its no longer possible to make            // is palindrome by one swap            if (diffCount == 2) return false;             // record the different character            diff[diffCount][0] = input[i];             // store the different characters            diff[diffCount++][1] = input[len - i - 1];        }    }         switch (diffCount)    {        // its already palindrome        case 0:            return true;         // only one difference is found        case 1:        {            char midChar = input[i];             // if the middleChar matches either of            // the difference producing characters,            // return true            if (len % 2 != 0 and               (diff[0][0] == midChar or                diff[0][1] == midChar))                return true;        }                 // two differences are found        case 2:             // if the characters contained in            // the two sets are same, return true            if ((diff[0][0] == diff[1][0] and                 diff[0][1] == diff[1][1]) or                (diff[0][0] == diff[1][1] and                 diff[0][1] == diff[1][0]))                return true;    }    return false;} // Driver Codeint main(){    cout << boolalpha         << isPalindromePossible("bbg") << endl;    cout << boolalpha         << isPalindromePossible("bdababd") << endl;    cout << boolalpha         << isPalindromePossible("gcagac") << endl;     return 0;} // This code is contributed by// sanjeev2552
// Java program palindrome by swapping// only one characterclass GFG {     public static boolean isPalindromePossible(String input)    {         // convert the string to character array        char[] charStr = input.toCharArray();        int len = input.length(), i;         // counts the number of differences which prevents        // the string from being palindrome.        int diffCount = 0;         // keeps a record of the characters that prevents        // the string from being palindrome.        char[][] diff = new char[2][2];         // loops from the start of a string till the midpoint        // of the string        for (i = 0; i < len / 2; i++) {             // difference is encountered preventing the string            // from being palindrome            if (charStr[i] != charStr[len - i - 1]) {                 // 3rd differences encountered and its no longer                // possible to make is palindrome by one swap                if (diffCount == 2)                    return false;                 // record the different character                diff[diffCount][0] = charStr[i];                 // store the different characters                diff[diffCount++][1] = charStr[len - i - 1];            }        }         switch (diffCount) {         // its already palindrome        case 0:            return true;         // only one difference is found        case 1:            char midChar = charStr[i];             // if the middleChar matches either of the            // difference producing characters, return true            if (len % 2 != 0 && (diff[0][0] == midChar                                 || diff[0][1] == midChar))                return true;         // two differences are found        case 2:             // if the characters contained in the two sets are same,            // return true            if ((diff[0][0] == diff[1][0] && diff[0][1] == diff[1][1])                || (diff[0][0] == diff[1][1] && diff[0][1] == diff[1][0]))                return true;        }        return false;    }     public static void main(String[] args)    {        System.out.println(isPalindromePossible("bbg"));        System.out.println(isPalindromePossible("bdababd"));        System.out.println(isPalindromePossible("gcagac"));    }}
# Python3 program palindrome by swapping# only one character def isPalindromePossible(input: str) -> bool:    length = len(input)     # counts the number of differences    # which prevents the string from    # being palindrome.    diffCount = 0    i = 0     # keeps a record of the characters    # that prevents the string from    # being palindrome.    diff = [['0'] * 2] * 2     # loops from the start of a string    # till the midpoint of the string    while i < length // 2:         # difference is encountered preventing        # the string from being palindrome        if input[i] != input[length - i - 1]:             # 3rd differences encountered and            # its no longer possible to make            # is palindrome by one swap            if diffCount == 2:                return False             # record the different character            diff[diffCount][0] = input[i]             # store the different characters            diff[diffCount][1] = input[length - i - 1]            diffCount += 1        i += 1     # its already palindrome    if diffCount == 0:        return True     # only one difference is found    elif diffCount == 1:        midChar = input[i]         # if the middleChar matches either of        # the difference producing characters,        # return true        if length % 2 != 0 and (diff[0][0] == midChar                                or diff[0][1] == midChar):            return True     # two differences are found    elif diffCount == 2:         # if the characters contained in        # the two sets are same, return true        if (diff[0][0] == diff[1][0] and diff[0][1] == diff[1][1]) or (                diff[0][0] == diff[1][1] and diff[0][1] == diff[1][0]):            return True    return False # Driver Codeif __name__ == "__main__":     print(isPalindromePossible("bbg"))    print(isPalindromePossible("bdababd"))    print(isPalindromePossible("gcagac")) # This code is contributed by# sanjeev2552
// C# program palindrome by swapping// only one characterusing System; class GFG{     public static bool isPalindromePossible(String input)    {         // convert the string to character array        char[] charStr = input.ToCharArray();        int len = input.Length, i;         // counts the number of differences        // which prevents the string        // from being palindrome.        int diffCount = 0;         // keeps a record of the        // characters that prevents        // the string from being palindrome.        char[,] diff = new char[2, 2];         // loops from the start of a string        // till the midpoint of the string        for (i = 0; i < len / 2; i++)        {             // difference is encountered preventing            // the string from being palindrome            if (charStr[i] != charStr[len - i - 1])            {                 // 3rd differences encountered                // and its no longer possible to                // make is palindrome by one swap                if (diffCount == 2)                    return false;                 // record the different character                diff[diffCount, 0] = charStr[i];                 // store the different characters                diff[diffCount++, 1] = charStr[len - i - 1];            }        }         switch (diffCount)        {             // its already palindrome            case 0:                return true;             // only one difference is found            case 1:                char midChar = charStr[i];             // if the middleChar matches either of the            // difference producing characters, return true            if (len % 2 != 0 &&                (diff[0,0] == midChar ||                diff[0,1] == midChar))                return true;            break;                     // two differences are found            case 2:             // if the characters contained in            // the two sets are same, return true            if ((diff[0,0] == diff[1,0] &&                 diff[0,1] == diff[1,1]) ||                 (diff[0,0] == diff[1,1] &&                 diff[0,1] == diff[1,0]))                return true;            break;        }        return false;    }     // Driver code    public static void Main(String[] args)    {        Console.WriteLine(isPalindromePossible("bbg"));        Console.WriteLine(isPalindromePossible("bdababd"));        Console.WriteLine(isPalindromePossible("gcagac"));    }} // This code is contributed by PrinciRaj1992
<script> // JavaScript program palindrome by swapping// only one character function isPalindromePossible(input){         let Length = input.length     // counts the number of differences    // which prevents the string from    // being palindrome.    let diffCount = 0,i = 0     // keeps a rec||d of the characters    // that prevents the string from    // being palindrome.    let diff = new Array(2).fill(0).map(()=>new Array(2))     // loops from the start of a string    // till the midpoint of the string    for (i = 0; i < Math.floor(Length / 2); i++)    {         // difference is encountered preventing        // the string from being palindrome        if(input[i] != input[Length - i - 1]){             // 3rd differences encountered &&            // its no longer possible to make            // is palindrome by one swap            if(diffCount == 2)                return false             // rec||d the different character            diff[diffCount][0] = input[i]             // st||e the different characters            diff[diffCount++][1] = input[Length - i - 1]        }    }     switch (diffCount)    {        // its already palindrome        case 0:            return true          // only one difference is found        case 1:        {            let midChar = input[i]              // if the middleChar matches either of            // the difference producing characters,            // return true            if (Length % 2 != 0 &&               (diff[0][0] == midChar ||                diff[0][1] == midChar))                return true        }                  // two differences are found        case 2:              // if the characters contained in            // the two sets are same, return true            if ((diff[0][0] == diff[1][0] &&                 diff[0][1] == diff[1][1]) ||                (diff[0][0] == diff[1][1] &&                 diff[0][1] == diff[1][0]))                return true    }    return false} // driver code document.write(isPalindromePossible("bbg"),"</br>")document.write(isPalindromePossible("bdababd"),"</br>")document.write(isPalindromePossible("gcagac"),"</br>") // This code is contributed by shinjanpatra </script>
true
true
false
 
Time Complexity : O(n) Auxiliary Space : O(1) 
princiraj1992
sanjeev2552
nnr223442
shinjanpatra
palindrome
Java Programs
Strings
Strings
palindrome
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Factory method design pattern in Java
Java Program to Remove Duplicate Elements From the Array
Java program to count the occurrence of each character in a string using Hashmap
Iterate through List in Java
How to Iterate HashMap in Java?
Write a program to reverse an array or string
Reverse a string in Java
Write a program to print all permutations of a given string
C++ Data Types
Check for Balanced Brackets in an expression (well-formedness) using Stack