# Form the largest number using at most one swap operation

Given a non-negative number num. The problem is to apply at most one swap operation on the number num so that the resultant is the largest possible number. The number could be very large so a string type can be used to store the number.

Examples:

```Input : n = 8725634
Output : 8765234
Swapped the digits 2 and 6.

Input : n = 54321
Output : 54321
No swapping of digits required.
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Create an array rightMax[]. rightMax[i] contains the index of the greatest digit which is on the right side of num[i] and also greater than num[i]. If no such digit exists then rightMax[i] = -1. Now, traverse the rightMax[] array from i = 0 to n-1(where n is the total number of digits in num), and find the first element having rightMax[i] != -1. Perform the swap(num[i], num[rightMax[i]]) operation and break.

## C++

 `// C++ implementation to form the largest number ` `// by applying atmost one swap operation ` `#include ` `using` `namespace` `std; ` ` `  `// function to form the largest number by ` `// applying atmost one swap operation ` `string largestNumber(string num) ` `{ ` `    ``int` `n = num.size(); ` `    ``int` `rightMax[n], right; ` ` `  `    ``// for the rightmost digit, there ` `    ``// will be no greater right digit ` `    ``rightMax[n - 1] = -1; ` ` `  `    ``// index of the greatest right digit till the ` `    ``// current index from the right direction ` `    ``right = n - 1; ` ` `  `    ``// traverse the array from second right element ` `    ``// up to the left element ` `    ``for` `(``int` `i = n - 2; i >= 0; i--) { ` ` `  `        ``// if 'num[i]' is less than the greatest digit ` `        ``// encountered so far ` `        ``if` `(num[i] < num[right]) ` `            ``rightMax[i] = right; ` ` `  `        ``// else ` `        ``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 < n; i++) { ` ` `  `        ``// if for the current digit, greater right digit exists ` `        ``// then swap it with its greater right digit and break ` `        ``if` `(rightMax[i] != -1) { ` ` `  `            ``// performing the required swap operation ` `            ``swap(num[i], num[rightMax[i]]); ` `            ``break``; ` `        ``} ` `    ``} ` ` `  `    ``// required largest number ` `    ``return` `num; ` `} ` ` `  `// Driver program to test above ` `int` `main() ` `{ ` `    ``string num = ``"8725634"``; ` `    ``cout << ``"Largest number:"` `         ``<< largestNumber(num); ` `    ``return` `0; ` `} `

## Java

 `//Java implementation to form the largest number ` `//by applying utmost one swap operation ` `public` `class` `GFG ` `{ ` `    ``// function to form the largest number by ` `    ``// applying utmost one swap operation ` `    ``static` `String largestNumber(String num) ` `    ``{ ` `        ``int` `n = num.length(); ` `        ``int` `right; ` `        ``int` `rightMax[] = ``new` `int``[n]; ` ` `  `        ``// for the rightmost digit, there ` `        ``// will be no greater right digit ` `        ``rightMax[n - ``1``] = -``1``; ` ` `  `        ``// index of the greatest right digit ` `        ``// till the current index from the ` `        ``// right direction ` `        ``right = n - ``1``; ` ` `  `        ``// traverse the array from second right ` `        ``// element up to the left element ` `        ``for` `(``int` `i = n - ``1``; i >= ``0` `; i--) ` `        ``{ ` `            ``// if 'num.charAt(i)' is less than the ` `            ``// greatest digit encountered so far ` `            ``if` `(num.charAt(i) < num.charAt(right)) ` `                ``rightMax[i] = right; ` ` `  `            ``else` `            ``{ ` `                ``// there is no greater right digit ` `                ``// for 'num.charAt(i)' ` `                ``rightMax[i] = -``1``; ` ` `  `                ``// update 'right' index ` `                ``right = i; ` `            ``} ` `        ``} ` ` `  `        ``// traverse the 'rightMax[]' array from ` `        ``// left to right ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{ ` ` `  `            ``// if for the current digit, greater ` `            ``// right digit exists then swap it ` `            ``// with its greater right digit and break ` `            ``if` `(rightMax[i] != -``1``) ` `            ``{ ` `                ``// performing the required swap operation ` `                ``num = swap(num,i,rightMax[i]); ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// required largest number ` `        ``return` `num; ` `    ``} ` ` `  `    ``// Utility method to swap two characters ` `    ``// in a String ` `    ``static` `String swap(String num, ``int` `i, ``int` `j) ` `    ``{ ` `        ``StringBuilder sb= ``new` `StringBuilder(num); ` `        ``sb.setCharAt(i, num.charAt(j)); ` `        ``sb.setCharAt(j, num.charAt(i)); ` `        ``return` `sb.toString(); ` ` `  `    ``} ` ` `  `    ``//Driver Function to test above Function ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``String num = ``"8725634"``; ` `        ``System.out.println(``"Largest Number : "` `+ ` `                              ``largestNumber(num)); ` `    ``} ` ` `  `} ` `//This code is contributed by Sumit Ghosh `

## Python

 `# Python implementation to form the largest number ` `# by applying atmost one swap operation ` ` `  `# function to form the largest number by ` `# applying atmost one swap operation ` `def` `largestNumber(num): ` `    ``n ``=` `len``(num) ` `    ``rightMax ``=` `[``0` `for` `i ``in` `range``(n)] ` `  `  `    ``# for the rightmost digit, there ` `    ``# will be no greater right digit ` `    ``rightMax[n ``-` `1``] ``=` `-``1` `  `  `    ``# index of the greatest right digit till the ` `    ``# current index from the right direction ` `    ``right ``=` `n ``-` `1` `  `  `    ``# traverse the array from second right element ` `    ``# up to the left element ` `    ``i ``=` `n ``-` `2` `    ``while` `i >``=` `0``: ` `         `  `        ``# if 'num[i]' is less than the greatest digit ` `        ``# encountered so far ` `        ``if` `(num[i] < num[right]): ` `            ``rightMax[i] ``=` `right ` `  `  `        ``# else ` `        ``else``: ` `            ``# there is no greater right digit ` `            ``# for 'num[i]' ` `            ``rightMax[i] ``=` `-``1` `  `  `            ``# update 'right' index ` `            ``right ``=` `i ` `        ``i ``-``=` `1` `         `  `    ``# traverse the 'rightMax[]' array from left to right ` `    ``for` `i ``in` `range``(n): ` `         `  `        ``# if for the current digit, greater right digit exists ` `        ``# then swap it with its greater right digit and break ` `        ``if` `(rightMax[i] !``=` `-``1``): ` `             `  `            ``# performing the required swap operation ` `            ``t ``=` `num[i] ` `             `  `            ``num[i] ``=` `num[rightMax[i]] ` `            ``num[rightMax[i]] ``=` `t ` `            ``break` `     `  `    ``# required largest number ` `    ``return` `num ` `  `  `# Driver program to test above ` `num ``=` `"8725634"` `li ``=` `[i ``for` `i ``in` `num] ` `print` `"Largest number: "` `li ``=` `largestNumber(li) ` `for` `i ``in` `li: ` `    ``print` `i, ` `print` ` `  `#This code is contributed by Sachin Bisht `

## C#

 `// C# implementation to form the largest number ` `// by applying utmost one swap operation ` ` `  `using` `System; ` `using` `System.Text; ` `public` `class` `GFG ` `{ ` `    ``// function to form the largest number by ` `    ``// applying utmost one swap operation ` `    ``static` `String largestNumber(String num) ` `    ``{ ` `        ``int` `n = num.Length; ` `        ``int` `right; ` `        ``int``[] rightMax = ``new` `int``[n]; ` ` `  `        ``// for the rightmost digit, there ` `        ``// will be no greater right digit ` `        ``rightMax[n - 1] = -1; ` ` `  `        ``// index of the greatest right digit ` `        ``// till the current index from the ` `        ``// right direction ` `        ``right = n - 1; ` ` `  `        ``// traverse the array from second right ` `        ``// element up to the left element ` `        ``for` `(``int` `i = n - 1; i >= 0 ; i--) ` `        ``{ ` `            ``// if 'num.charAt(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.charAt(i)' ` `                ``rightMax[i] = -1; ` ` `  `                ``// update 'right' index ` `                ``right = i; ` `            ``} ` `        ``} ` ` `  `        ``// traverse the 'rightMax[]' array from ` `        ``// left to right ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` ` `  `            ``// if for the current digit, greater ` `            ``// right digit exists then swap it ` `            ``// with its greater right digit and break ` `            ``if` `(rightMax[i] != -1) ` `            ``{ ` `                ``// performing the required swap operation ` `                ``num = swap(num,i,rightMax[i]); ` `                ``break``; ` `            ``} ` `        ``} ` ` `  `        ``// required largest number ` `        ``return` `num; ` `    ``} ` ` `  `    ``// Utility method to swap two characters ` `    ``// in a String ` `    ``static` `String swap(String num, ``int` `i, ``int` `j) ` `    ``{ ` `        ``StringBuilder sb= ``new` `StringBuilder(num); ` `        ``sb[i]=num[j]; ` `        ``sb[j]=num[i]; ` `        ``return` `sb.ToString(); ` ` `  `    ``} ` ` `  `    ``//Driver Function to test above Function ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``String num = ``"8725634"``; ` `        ``Console.WriteLine(``"Largest Number : "` `+largestNumber(num)); ` `    ``} ` ` `  `} ` `//This code is contributed by mits `

## PHP

 `= 0; ``\$i``--)  ` `    ``{  ` ` `  `        ``// if 'num[i]' is less than the ` `        ``// greatest digit encountered so far  ` `        ``if` `(``\$num``[``\$i``] < ``\$num``[``\$right``])  ` `            ``\$rightMax``[``\$i``] = ``\$right``;  ` ` `  `        ``// else  ` `        ``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` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `    ``{  ` ` `  `        ``// if for the current digit, greater  ` `        ``// right digit exists then swap it  ` `        ``// with its greater right digit and break  ` `        ``if` `(``\$rightMax``[``\$i``] != -1) ` `        ``{  ` ` `  `            ``// performing the required swap operation  ` `            ``list(``\$num``[``\$i``],  ` `                 ``\$num``[``\$rightMax``[``\$i``]]) = ``array``(``\$num``[``\$rightMax``[``\$i``]], ` `                                              ``\$num``[``\$i``]); ` `         `  `            ``break``;  ` `        ``}  ` `    ``}  ` ` `  `    ``// required largest number  ` `    ``return` `\$num``;  ` `}  ` ` `  `// Driver Code ` `\$num` `= ``"8725634"``;  ` `echo` `"Largest number: "``, ` `     ``largestNumber(``\$num``);  ` ` `  `// This code is contributed by jit_t ` `?> `

Output:

```Largest number: 8765234
```

Time Complexity: O(n), where n is the total number of digits.
Auxiliary Space: O(n), where n is the total number of digits.

This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Improved By : jit_t, Mithun Kumar

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.