Skip to content
Related Articles
Form the largest palindromic number using atmost two swaps
• Difficulty Level : Medium
• Last Updated : 17 Jun, 2019

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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.

## 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 halft``        ``// 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``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 halft ``        ``// 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 halft``        ``# 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`

Output:

```Largest Palindrome: 9647557469
```

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

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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up