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++ implementation to form the largest palindromic // number using atmost two swaps #include <bits/stdc++.h> 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 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 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# 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 |
<script> // JavaScript implementation to form the largest palindromic // number using atmost two swaps // function to form the largest palindromic // number using atmost two swaps function 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'
let mid = Math.floor(n / 2) - 1;
let rightMax = new Array(mid + 1);
let 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 (let 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 (let 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 ;
}
}
} function swap(arr,i,j)
{ let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
return arr;
} // Driver code let num = "4697557964" .split( "" );
let n = num.length; largestPalin(num, n); // required largest palindromic number document.write( "Largest Palindrome: "
+ (num).join( "" ));
// This code is contributed by rag2127 </script> |
Largest Palindrome: 9647557469
Time Complexity: O(n).
Auxiliary Space: O(n).