Get the best out of our app
GeeksforGeeks App
Open App
Browser
Continue

# Form the largest palindromic number using atmost two swaps

Given a non-negative palindromic number num containing n number of digits. The problem is to apply at most two swap operations on the number num so that the resultant is the largest possible palindromic number.

Examples:

```Input  : 4697557964
Output : 9647557469
In, 4697557964 the highlighted digits were
swapped to get the largest palindromic number
9647557469.

Input : 54345
Output : 54345
No swapping of digits required.```

Approach:  If n < 3, then num itself is the largest possible palindromic number. Else calculate mid = (n / 2) – 1. Then create an array rightMax[] of size (mid + 1). rightMax[i] contains the index of the greatest digit which is on the right side of num[i] and also greater than num[i] and 0 <= i <= mid. If no such digit exists then rightMax[i] = -1.

Now, traverse the rightMax[] array from i = 0 to m, and find the first element having rightMax[i] != -1. Perform the swap(num[i], num[rightMax[i]]) and swap(num[n – i – 1], num[n – rightMax[i] – 1]) operations and break.

Implementation:

## C++

 `// C++ implementation to form the largest palindromic``// number using atmost two swaps``#include ` `using` `namespace` `std;` `// function to form the largest palindromic``// number using atmost two swaps``void` `largestPalin(``char` `num[], ``int` `n)``{``    ``// if length of number is less than '3'``    ``// then no higher palindromic number``    ``// can be formed``    ``if` `(n <= 3)``        ``return``;` `    ``// find the index of last digit``    ``// in the 1st half of 'num'``    ``int` `mid = n / 2 - 1;` `    ``int` `rightMax[mid + 1], right;` `    ``// as only the first half of 'num[]' is``    ``// being considered, therefore``    ``// for the rightmost digit in the first half``    ``// of 'num[]', there will be no greater right digit``    ``rightMax[mid] = -1;` `    ``// index of the greatest right digit till the``    ``// current index from the right direction``    ``right = mid;` `    ``// traverse the array from second right element``    ``// in the first half of 'num[]' up to the``    ``// left element``    ``for` `(``int` `i = mid - 1; i >= 0; i--) {` `        ``// if 'num[i]' is less than the greatest digit``        ``// encountered so far``        ``if` `(num[i] < num[right])``            ``rightMax[i] = right;` `        ``else` `{` `            ``// there is no greater right digit``            ``// for 'num[i]'``            ``rightMax[i] = -1;` `            ``// update 'right' index``            ``right = i;``        ``}``    ``}` `    ``// traverse the 'rightMax[]' array from left to right``    ``for` `(``int` `i = 0; i <= mid; i++) {` `        ``// if for the current digit, greater right digit exists``        ``// then swap it with its greater right digit and also``        ``// perform the required swap operation in the right half``        ``// of 'num[]' to maintain palindromic property, then break``        ``if` `(rightMax[i] != -1) {` `            ``// performing the required swap operations``            ``swap(num[i], num[rightMax[i]]);``            ``swap(num[n - i - 1], num[n - rightMax[i] - 1]);``            ``break``;``        ``}``    ``}``}` `// Driver program to test above``int` `main()``{``    ``char` `num[] = ``"4697557964"``;``    ``int` `n = ``strlen``(num);``    ``largestPalin(num, n);` `    ``// required largest palindromic number``    ``cout << ``"Largest Palindrome: "``         ``<< num;` `    ``return` `0;``}`

## Java

 `// Java implementation to form the largest palindromic``// number using atmost two swaps``import` `java.io.*;``public` `class` `GFG``{` `// function to form the largest palindromic``// number using atmost two swaps``static` `void` `largestPalin(``char` `num[], ``int` `n)``{``    ``// if length of number is less than '3'``    ``// then no higher palindromic number``    ``// can be formed``    ``if` `(n <= ``3``)``        ``return``;` `    ``// find the index of last digit``    ``// in the 1st half of 'num'``    ``int` `mid = n / ``2` `- ``1``;` `    ``int` `[]rightMax = ``new` `int``[mid + ``1``];``int` `right;` `    ``// as only the first half of 'num[]' is``    ``// being considered, therefore``    ``// for the rightmost digit in the first half``    ``// of 'num[]', there will be no greater right digit``    ``rightMax[mid] = -``1``;` `    ``// index of the greatest right digit till the``    ``// current index from the right direction``    ``right = mid;` `    ``// traverse the array from second right element``    ``// in the first half of 'num[]' up to the``    ``// left element``    ``for` `(``int` `i = mid - ``1``; i >= ``0``; i--)``    ``{` `        ``// if 'num[i]' is less than the greatest digit``        ``// encountered so far``        ``if` `(num[i] < num[right])``            ``rightMax[i] = right;` `        ``else``        ``{` `            ``// there is no greater right digit``            ``// for 'num[i]'``            ``rightMax[i] = -``1``;` `            ``// update 'right' index``            ``right = i;``        ``}``    ``}` `    ``// traverse the 'rightMax[]' array from left to right``    ``for` `(``int` `i = ``0``; i <= mid; i++)``    ``{` `        ``// if for the current digit, greater right digit exists``        ``// then swap it with its greater right digit and also``        ``// perform the required swap operation in the right half``        ``// of 'num[]' to maintain palindromic property, then break``        ``if` `(rightMax[i] != -``1``)``        ``{` `            ``// performing the required swap operations``            ``swap(num,i, rightMax[i]);``            ``swap(num,n - i - ``1``, n - rightMax[i] - ``1``);``            ``break``;``        ``}``    ``}``}` `static` `char``[] swap(``char` `[]arr, ``int` `i, ``int` `j)``{``    ``char` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``    ``return` `arr;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``char` `num[] = ``"4697557964"``.toCharArray();``    ``int` `n = num.length;``    ``largestPalin(num, n);` `    ``// required largest palindromic number``    ``System.out.println(``"Largest Palindrome: "``        ``+ String.valueOf(num));``}``}` `// This code has been contributed by 29AjayKumar`

## Python 3

 `# Python implementation to form the largest``# palindromic number using atmost two swaps` `# function to form the largest palindromic``# number using atmost two swaps``def` `largestPalin(num, n):` `    ``# if length of number is less than '3'``    ``# then no higher palindromic number``    ``# can be formed``    ``if` `n <``=` `3``:``        ``return` `    ``# find the index of last digit``    ``# in the 1st half of 'num'``    ``mid ``=` `n ``/``/` `2` `+` `1` `    ``rightMax ``=` `[``0``] ``*` `(mid ``+` `1``)` `    ``# as only the first half of 'num[]' is``    ``# being considered, therefore``    ``# for the rightmost digit in the first half``    ``# of 'num[]', there will be no greater right digit``    ``rightMax[mid] ``=` `-``1` `    ``# index of the greatest right digit till the``    ``# current index from the right direction``    ``right ``=` `mid` `    ``# traverse the array from second right element``    ``# in the first half of 'num[]' up to the``    ``# left element``    ``for` `i ``in` `range``(mid``-``1``, ``-``1``, ``-``1``):``        ` `        ``# if 'num[i]' is less than the greatest digit``        ``# encountered so far``        ``if` `num[i] < num[right]:``            ``rightMax[i] ``=` `right` `        ``else``:` `            ``# there is no greater right digit``            ``# for 'num[i]'``            ``rightMax[i] ``=` `-``1` `            ``# update 'right' index``            ``right ``=` `i` `    ``# traverse the 'rightMax[]' array from left to right``    ``for` `i ``in` `range``(mid ``+` `1``):` `        ``# if for the current digit, greater right digit exists``        ``# then swap it with its greater right digit and also``        ``# perform the required swap operation in the right half``        ``# of 'num[]' to maintain palindromic property, then break``        ``if` `rightMax[i] !``=` `-``1``:` `            ``# performing the required swap operations``            ``num[i], num[rightMax[i]] ``=` `num[rightMax[i]], num[i]``            ``num[n``-``i``-``1``], num[n ``-` `rightMax[i] ``-` `1``] ``=` `num[n ``-` `rightMax[i] ``-` `1``], num[n ``-` `i ``-` `1``]``            ``break`  `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``num ``=` `"4697557964"``    ``n ``=` `len``(num)``    ` `    ``# Required as string object do not``    ``# support item assignment``    ``num ``=` `list``(num)``    ``largestPalin(num, n)` `    ``# making string again from list``    ``num ``=` `''.join(num)``    ``print``(``"Largest Palindrome: "``,num)` `# This code is contributed by``# sanjeev2552`

## C#

 `// C# implementation to form the largest``// palindromic number using atmost two swaps``using` `System;` `class` `GFG``{` `// function to form the largest palindromic``// number using atmost two swaps``static` `void` `largestPalin(``char` `[]num, ``int` `n)``{``    ``// if length of number is less than '3'``    ``// then no higher palindromic number``    ``// can be formed``    ``if` `(n <= 3)``        ``return``;` `    ``// find the index of last digit``    ``// in the 1st half of 'num'``    ``int` `mid = n / 2 - 1;` `    ``int` `[]rightMax = ``new` `int``[mid + 1]; ``int` `right;` `    ``// as only the first half of 'num[]' is``    ``// being considered, therefore``    ``// for the rightmost digit in the first half``    ``// of 'num[]', there will be no greater right digit``    ``rightMax[mid] = -1;` `    ``// index of the greatest right digit till the``    ``// current index from the right direction``    ``right = mid;` `    ``// traverse the array from second right element``    ``// in the first half of 'num[]' up to the``    ``// left element``    ``for` `(``int` `i = mid - 1; i >= 0; i--)``    ``{` `        ``// if 'num[i]' is less than the greatest``        ``// digit encountered so far``        ``if` `(num[i] < num[right])``            ``rightMax[i] = right;` `        ``else``        ``{` `            ``// there is no greater right digit``            ``// for 'num[i]'``            ``rightMax[i] = -1;` `            ``// update 'right' index``            ``right = i;``        ``}``    ``}` `    ``// traverse the 'rightMax[]' array``    ``// from left to right``    ``for` `(``int` `i = 0; i <= mid; i++)``    ``{` `        ``// if for the current digit, greater right``        ``// digit exists then swap it with its greater``        ``// right digit and also perform the required``        ``// swap operation in the right half of 'num[]'``        ``// to maintain palindromic property, then break``        ``if` `(rightMax[i] != -1)``        ``{` `            ``// performing the required swap operations``            ``swap(num, i, rightMax[i]);``            ``swap(num, n - i - 1, n - rightMax[i] - 1);``            ``break``;``        ``}``    ``}``}` `static` `char``[] swap(``char` `[]arr, ``int` `i, ``int` `j)``{``    ``char` `temp = arr[i];``    ``arr[i] = arr[j];``    ``arr[j] = temp;``    ``return` `arr;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``char` `[]num = ``"4697557964"``.ToCharArray();``    ``int` `n = num.Length;``    ``largestPalin(num, n);` `    ``// required largest palindromic number``    ``Console.WriteLine(``"Largest Palindrome: "` `+``                        ``String.Join(``""``, num));``}``}` `// This code contributed by Rajput-Ji`

## Javascript

 ``

Output

`Largest Palindrome: 9647557469`

Time Complexity: O(n).
Auxiliary Space: O(n).

My Personal Notes arrow_drop_up