Given a non-negative number N in the form of string. The task is to apply at most one swap operation on the number N so that the resultant is smaller than N and is the largest such number.
Examples:
Input :str = "12435" Output : 12345 Although the number 12354 will be the largest smaller number from 12435. But it is not possible to make it using only one swap. So swap 4 and 3 and get 12345. Input : 34123567 Output : 33124567 We swap 4 with 3 (on its right side) to get the largest smaller number. Input : str = " 12345" Output : -1 Digits are in increasing order. So it is not possible to make a smaller number from it.
Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.
- Start traversing from right, find a digit is which is greater than one of the digits on its right. Let this index such element be index.
- Then find another index on right of str[index] which holds the greatest value smaller than str[index].
- Swap two values found above.
C++
// C++ program to find the largest smaller // number by swapping one digit. #include <bits/stdc++.h> using namespace std;
// Returns largest possible number with one // swap such that the number is smaller than // str. It is assumed that there are leading // 0s. string prevNum(string str) { int len = str.length();
int index = -1;
// Traverse from right until we find
// a digit which is greater than its
// next digit. For example, in 34125,
// our index is 4.
for ( int i = len - 2; i >= 0; i--) {
if (str[i] > str[i+1])
{
index = i;
break ;
}
}
// We can also use binary search here as
// digits after index are sorted in increasing
// order.
// Find the biggest digit in the right of
// arr[index] which is smaller than arr[index]
int smallGreatDgt = -1;
for ( int i = len - 1; i > index; i--) {
if (str[i] < str[index]) {
if (smallGreatDgt == -1)
smallGreatDgt = i;
else if (str[i] >= str[smallGreatDgt])
smallGreatDgt = i;
}
}
// If index is -1 i.e. digits are
// in increasing order.
if (index == -1)
return "-1" ;
// Swap both values
if (smallGreatDgt != -1)
{
swap(str[index], str[smallGreatDgt]);
return str;
}
return "-1" ;
} // Drivers code int main()
{ string str = "34125" ;
cout << prevNum(str);
return 0;
} |
Java
// Java program to find the largest smaller // number by swapping one digit. import java.io.*;
public class GFG
{ // Returns largest possible number
// with one swap such that the number
// is smaller than str. It is assumed
// that there are leading 0s.
static String prevNum(String str)
{
int len = str.length();
int index = - 1 ;
// Traverse from right until we find
// a digit which is greater than its
// next digit. For example, in 34125,
// our index is 4.
for ( int i = len - 2 ; i >= 0 ; i--)
{
if (str.charAt(i) > str.charAt(i + 1 ))
{
index = i;
break ;
}
}
// We can also use binary search here as
// digits after index are sorted in increasing
// order.
// Find the biggest digit in the right of
// arr[index] which is smaller than arr[index]
int smallGreatDgt = - 1 ;
for ( int i = len - 1 ; i > index; i--)
{
if (str.charAt(i) < str.charAt(index))
{
if (smallGreatDgt == - 1 )
{
smallGreatDgt = i;
}
else if (str.charAt(i) >=
str.charAt(smallGreatDgt))
{
smallGreatDgt = i;
}
}
}
// If index is -1 i.e. digits are
// in increasing order.
if (index == - 1 )
{
return "-1" ;
}
// Swap both values
if (smallGreatDgt != - 1 )
{
str = swap(str, index, smallGreatDgt);
return str;
}
return "-1" ;
}
static String swap(String str, int i, int j)
{
char ch[] = str.toCharArray();
char temp = ch[i];
ch[i] = ch[j];
ch[j] = temp;
return String.valueOf(ch);
}
// Driver code
public static void main(String[] args)
{
String str = "34125" ;
System.out.println(prevNum(str));
}
} // This code is contributed by 29AjayKumar |
Python3
# Python3 program to find the largest smaller # number by swapping one digit. import sys
# Returns largest possible number # with one swap such that the number # is smaller than str. It is assumed # that there are leading 0s. def prevNum(string, n):
index = - 1
# Traverse from right until we find
# a digit which is greater than its
# next digit. For example, in 34125,
# our index is 4.
for i in range (n - 2 , - 1 , - 1 ):
if int (string[i]) > int (string[i + 1 ]):
index = i
break
# We can also use binary search here as
# digits after index are sorted in
# increasing order.
# Find the biggest digit in the right of
# arr[index] which is smaller than arr[index]
smallGreatDgt = - 1
for i in range (n - 1 , index, - 1 ):
if (smallGreatDgt = = - 1 and int (string[i]) <
int (string[index])):
smallGreatDgt = i
elif (index > - 1 and int (string[i]) > =
int (string[smallGreatDgt]) and
int (string[i]) < int (string[index])):
smallGreatDgt = i
# If index is -1 i.e. digits are
# in increasing order.
if index = = - 1 :
return " " . join(" - 1 ")
else :
# Swap both values
(string[index],
string[smallGreatDgt]) = (string[smallGreatDgt],
string[index])
return "" . join(string)
# Driver Code if __name__ = = '__main__' :
n_str = "34125"
ans = prevNum( list (n_str), len (n_str))
print (ans)
# This code is contributed by Vikash Kumar 37 |
C#
// C# program to find the largest smaller // number by swapping one digit. using System;
class GFG
{ // Returns largest possible number
// with one swap such that the number
// is smaller than str. It is assumed
// that there are leading 0s.
static String prevNum(String str)
{
int len = str.Length;
int index = -1;
// Traverse from right until we find
// a digit which is greater than its
// next digit. For example, in 34125,
// our index is 4.
for ( int i = len - 2; i >= 0; i--)
{
if (str[i] > str[i + 1])
{
index = i;
break ;
}
}
// We can also use binary search here as
// digits after index are sorted in increasing
// order.
// Find the biggest digit in the right of
// arr[index] which is smaller than arr[index]
int smallGreatDgt = -1;
for ( int i = len - 1; i > index; i--)
{
if (str[i] < str[index])
{
if (smallGreatDgt == -1)
{
smallGreatDgt = i;
}
else if (str[i] >=
str[smallGreatDgt])
{
smallGreatDgt = i;
}
}
}
// If index is -1 i.e. digits are
// in increasing order.
if (index == -1)
{
return "-1" ;
}
// Swap both values
if (smallGreatDgt != -1)
{
str = swap(str, index, smallGreatDgt);
return str;
}
return "-1" ;
}
static String swap(String str, int i, int j)
{
char [] ch = str.ToCharArray();
char temp = ch[i];
ch[i] = ch[j];
ch[j] = temp;
return String.Join( "" ,ch);
}
// Driver code
public static void Main(String[] args)
{
String str = "34125" ;
Console.WriteLine(prevNum(str));
}
} /* This code contributed by PrinciRaj1992 */ |
PHP
<?php // PHP program to find the // largest smaller number // by swapping one digit. // Returns largest possible // number with one swap such // that the number is smaller // than str. It is assumed // that there are leading // 0s. function prevNum( $str )
{ $len = strlen ( $str );
$index = -1;
// Traverse from right
// until we find a digit
// which is greater than
// its next digit. For
// example, in 34125,
// our index is 4.
for ( $i = $len - 2; $i >= 0; $i --)
{
if ( $str [ $i ] > $str [ $i + 1])
{
$index = $i ;
break ;
}
}
// We can also use binary
// search here as digits
// after index are sorted
// in increasing order.
// Find the biggest digit
// in the right of arr[index]
// which is smaller than
// arr[index]
$smallGreatDgt = -1;
for ( $i = $len - 1;
$i > $index ; $i --)
{
if ( $str [ $i ] < $str [ $index ])
{
if ( $smallGreatDgt == -1)
$smallGreatDgt = $i ;
else if ( $str [ $i ] >= $str [ $smallGreatDgt ])
$smallGreatDgt = $i ;
}
}
// If index is -1 i.e.
// digits are in
// increasing order.
if ( $index == -1)
return "-1" ;
// Swap both values
if ( $smallGreatDgt != -1)
{
list( $str [ $index ],
$str [ $smallGreatDgt ]) = array ( $str [ $smallGreatDgt ],
$str [ $index ]);
// swap(str[index],
// str[smallGreatDgt]);
return $str ;
}
return "-1" ;
} // Driver code $str = "34125" ;
echo prevNum( $str );
// This code is contributed // by akt_mit ?> |
Javascript
<script> // Javascript program to find the largest smaller
// number by swapping one digit.
// Returns largest possible number
// with one swap such that the number
// is smaller than str. It is assumed
// that there are leading 0s.
function prevNum(str)
{
let len = str.length;
let index = -1;
// Traverse from right until we find
// a digit which is greater than its
// next digit. For example, in 34125,
// our index is 4.
for (let i = len - 2; i >= 0; i--)
{
if (str[i] > str[i + 1])
{
index = i;
break ;
}
}
// We can also use binary search here as
// digits after index are sorted in increasing
// order.
// Find the biggest digit in the right of
// arr[index] which is smaller than arr[index]
let smallGreatDgt = -1;
for (let i = len - 1; i > index; i--)
{
if (str[i] < str[index])
{
if (smallGreatDgt == -1)
{
smallGreatDgt = i;
}
else if (str[i] >= str[smallGreatDgt])
{
smallGreatDgt = i;
}
}
}
// If index is -1 i.e. digits are
// in increasing order.
if (index == -1)
{
return "-1" ;
}
// Swap both values
if (smallGreatDgt != -1)
{
str = swap(str, index, smallGreatDgt);
return str;
}
return "-1" ;
}
function swap(str, i, j)
{
let ch = str.split( '' );
let temp = ch[i];
ch[i] = ch[j];
ch[j] = temp;
return ch.join( "" );
}
let str = "34125" ;
document.write(prevNum(str));
</script> |
Output:
32145
Time Complexity: O(N), where N is the size of the given string str
Auxiliary Space: O(1),as no extra space is required