Next Greater Number with Same Set of Digits in Java

A number (num) is given. The task is to find a number that is the smallest that comprises the same set of digits as num and must be larger than the number num. If the number num is the largest number possible with its digits set, then it is not possible to find the next greater number, and hence, a message should be displayed accordingly.

Example 1:

Input: 89321

Output: 91238

Explanation: Numbers that are made of the digits 1, 2, 3, 8, 9 and are larger than the number 89123 are:

98123, 98132, 98213, 98231, 98312, 98321, 93128, 93182, 93218, 93281, 93812, 93821, 92138, 92183, 92318, 92381, 92813, 92831, 91238, 91283, 91328, 91382, 91823, 91832

In all these number the smallest number is 91238.

Example 2:

Input: 3648

Output: 3684

Explanation: Numbers that are made of the digits 3, 8, 4, 6 and are larger than 3648 are:

3684, 4368, 4386, 4638, 4683, 4836, 4863, 6348, 6384, 6438, 6483, 6834, 6843, 8346, 8364, 8436, 8463, 8634, 8643

In all these number the smallest number is 3684.

Example 3:

Input: 9100

Output: It is not possible to find the next greater number.

Explanation: The largest number that is made of the digits 9, 1, 0, 0 is 9100. Thus, it is not possible to find a number that is greater than 9100 using the given digits.

Observation

The following are some of the important points of observation.

If the digits of a number are being arranged in the descending order, then the result is "It is not possible to find the next greater number". For example, 98675.
If the digits of a number are being arranged in the ascending order, then one needs to interchange the last two digits of the number. For example, for the number 4567, the next greater number is 4576.
For the rest of the other cases, one needs to begin the processing of the number from the rightmost side as one has to find the smallest among the numbers that are larger than the given number.

Algorithm

The following is the algorithm for computing the next greater number on the basis of the observation described above.

Step 1: Traverse the number num from the rightmost digit, keep traversing till one finds a digit that is lesser than the last traversed digit. For example, if one takes the input number as "4975", one has to stop at 4. It is because 4 is lesser than the next digit, 9. If one does not get such a digit, then it is not possible to find the next greater number.

Step 2: Now start searching the right side of the above found digit 'd' for the smallest digit larger than 'd'. For the number 4975, the right side of 4 contains 975. Out of the digits 9, 7, and 5, the smallest digit larger than 4 is 5.

Step 3: Now, swap the numbers 4 and 5. Thus, one will get 5974. However, this number is not the smallest among the largest. Therefore, we need to sort the digits after digit 5. Thus, by sorting the digits of the number 5974, one will get 5479. The number 5479 is the smallest among the numbers that are greater than the number 4975 and comprising of the digits 4, 9, 7, 5.

Using Permutation

It is a brute force approach. In this approach, we will be computing each number that can be formed using the digits present in the given number num. We will be storing those computed numbers in a hash set hs. In that hash set, we will be picking a number that is minimum as well as greater than the number num.

FileName: NextGreaterNumber.java

// important import statements
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;

public class NextGreaterNumber
{


public Set<Integer> hs;

// constructor of the class
NextGreaterNumber()
{
hs = new HashSet();
}

// a method that finds the next greater number
int findNextGreaterNum(int num)
{

int n = num;    
ArrayList<Integer> al = new ArrayList<Integer>();

// loop for extracting the digits of the number num
// and adding those digits to the array list in the reverse order
while(n != 0)
{
al.add(n % 10);
n = n / 10;
}

// permute to find all the numbers using the digits
// stored in the array list
permute(al, 0, al.size() - 1);

int ans = findMin(hs, num);

return ans;


}

// a method that finds the minimum from the set s
// that minimum should be greater than num
public int findMin(Set<Integer> s, int num)
{
int min = Integer.MAX_VALUE;


// making an integer array using the set S
Integer[] intArr = s.toArray(new Integer[s.size()]);


// size of the array
int size = intArr.length;

// the value of this flag will be true
// when a valid minimum is found
boolean flag = false;

for(int i = 0 ; i < size; i++)
{
int temp = intArr[i];

// the value we are going to find
// has to more than the number num
if(temp > num)
{
//  among the greater value we have to 
// pick the minimum
if(min > temp)
{
min = temp;

// minimum found!
// hence update the value of the  
// boolean flag
flag = true;
}
}

}


// if the value of flag is true
// return the minimum value
if(flag)
{
return min;
}


// if the control reaches here then it means 
// the minimum value is not found. Therefore, return 
// -1
return -1;
}


// swap the value in the array list al at the positions 
// x & y
public void swap(ArrayList<Integer> al, int x, int y)
{
int i = al.get(x);
int j = al.get(y);

al.set(x, j);
al.set(y, i);
}

// using the digits present in the array list 
// create a number. Note that the digits in the num 
//  has the same order that is there in the array list
// For example, al = [2, 3, 6, 1, 1, 9, 8], then the number formed
// will be 2361198
int composeNum(ArrayList<Integer> al)
{
int size = al.size();
int num = 0;

for(int i = 0; i < size; i++)
{
num = num * 10;
num = num + al.get(i);
}

return num;

}


// a method that finds out the numbers that can be composed
// using the digits present in the array list al
private void permute(ArrayList<Integer> al, int l, int r)
{
// handling the base case
if (l == r)
{
// compose the number using the digits present 
// in the array list and add it to the hash set
int num = composeNum(al);
hs.add(num);
}

else
{
for (int j = l; j <= r; j++)
{
// swap then apply recursion and then 
// again swap in order to backtrack
swap(al, l, j);
permute(al, l + 1, r);
swap(al, l, j);
}
}
}


// main method
public static void main(String[] argvs)
{
// creating an object of the class NextGreaterNumber
NextGreaterNumber obj = new NextGreaterNumber();

// input 1
int num = 536479;

int ans = obj.findNextGreaterNum(num);

System.out.println("For the number: " + num);

if(ans != -1)
{
System.out.println("The next greater number is: " + ans);
}
else
{
System.out.println("The next greater number is not possible.");    
}

System.out.println();

obj.hs.clear();

// input 2
num = 654321;

ans = obj.findNextGreaterNum(num);

System.out.println("For the number: " + num);

if(ans != -1)
{
System.out.println("The next greater number is: " + ans);
}
else
{
System.out.println("The next greater number is not possible.");    
}


System.out.println();

obj.hs.clear();

// input 3
num = 4876;

ans = obj.findNextGreaterNum(num);

System.out.println("For the number: " + num);

if(ans != -1)
{
System.out.println("The next greater number is: " + ans);
}
else
{
System.out.println("The next greater number is not possible.");    
}


}
}

Output:

For the number: 536479
The next greater number is: 536497

For the number: 654321
The next greater number is not possible.

For the number: 4876
The next greater number is: 6478

Complexity Analysis: In the above program, we have used backtracking to find the next greater number. Thus, the time complexity of the above program is exponential. Suppose the number num has d digits. Thus, the total numbers present in the hash set hs n!. Therefore, the space complexity of the above program is O(n!).

Using Sorting

FileName: NextGreaterNumber

// important import statements
import java.util.ArrayList;
import java.util.Collections;

public class NextGreaterNumber
{
boolean isSwapPossible(ArrayList<Integer> al)
{
int size = al.size();
int j;

// loop for traversing from right to left
for (j = size - 1; j > 0; j--)
{
int x = al.get(j);
int y = al.get(j - 1);


if (x > y) 
{
// we have got a digit that is 
// less than the next digit
// hence the processing starts right here
break;
}
}


if(j == 0)
{
// all digits of the numbers
// are arranged in descending order. Hence, the next greater number
// is not possible
return false;
}

int a = al.get(j - 1);
int min = j;

// Finding a digit that is greater than the digit
// located at (j - 1)th index. However, among the collection of the
// greater digits we have to pick the smallest
for (int k = j + 1; k < size; k++)
{
if (al.get(k) > a && al.get(k) < al.get(min))
{
min = k;
}
}

// swapping to get the greater number
int x = al.get(j - 1);
int y = al.get(min);
al.set(min, x);
al.set(j - 1, y);


// sorting for getting the smallest among the numbers 
//  that are larger than num
Collections.sort(al.subList(j, size));

return true;

}

// a method that finds the next greater number
int findNextGreaterNum(int num)
{

int n = num;    
ArrayList<Integer> al = new ArrayList<Integer>();

// loop for extracting the digits of the number num
// and adding those digits to the array list in the reverse order
while(n != 0)
{
al.add(n % 10);
n = n / 10;
}

// reversing the order of digits so that the current order is maintained
Collections.reverse(al);

// if the swap is possible, then return
// the next greater number
if(isSwapPossible(al))
{
int newNum = 0;
int size = al.size();

// loop for combining the digits present 
// in the list to create a new number, which is next greater 
// number number
for (int j = 0; j < size; j++)
{
newNum = newNum * 10;
newNum = newNum + al.get(j);
}

// returning the new greater number
return newNum;
}



// if the control reaches here, then it means the next greater number is not 
// possible. Hence, -1 is returned
return -1;
}


// main method
public static void main(String[] argvs)
{
// creating an object of the class NextGreaterNumber
NextGreaterNumber obj = new NextGreaterNumber();

// input 1
int num = 536479;

int ans = obj.findNextGreaterNum(num);

System.out.println("For the number: " + num);

if(ans != -1)
{
System.out.println("The next greater number is: " + ans);
}
else
{
System.out.println("The next greater number is not possible.");    
}

System.out.println();

// input 2
num = 654321;

ans = obj.findNextGreaterNum(num);

System.out.println("For the number: " + num);

if(ans != -1)
{
System.out.println("The next greater number is: " + ans);
}
else
{
System.out.println("The next greater number is not possible.");    
}


System.out.println();


// input 3
num = 4876;

ans = obj.findNextGreaterNum(num);

System.out.println("For the number: " + num);

if(ans != -1)
{
System.out.println("The next greater number is: " + ans);
}
else
{
System.out.println("The next greater number is not possible.");    
}


}
}

Output:

For the number: 536479
The next greater number is: 536497

For the number: 654321
The next greater number is not possible.

For the number: 4876
The next greater number is: 6478

Complexity Analysis: In the above program, we have used loops as well as sorting. The loop takes O(n) time, and the sorting takes O(n * log(n)) time. Hence, the total time complexity of the program is O(n + n * log(n)), where n is the total number of digits present in the input number. As no extra space is used; therefore, the space complexity of the program is constant, i.e., O(1).

Note: We can even reduce the time complexity further. Note that instead of sorting, we can also use the inbuild reverse method to do the sorting. It is because the digits that we are sorting are arranged in descending order. For example, sorting 6, 5, 4, 3, 2, 1 should not take O(n x log(n)) time. Only reversing the order will do the job. So, instead of sorting, use the reverse() method to reduce the time complexity to O(n).

In the method isSwapPossible(), make the following changes to get the same result.

    boolean isSwapPossible(ArrayList<Integer> al)
    {
          // same code as the mentioned in the above program for this method            
           // comment out the Collections.sort() and add Collections.reverse() method 
           // Collections.sort(al.subList(j, size));
            
           // reverse the digits to find the next greater number
          Collections.reverse(al.subList(j, size));
          
     

        return true;
        
    }

Next TopicSplit the Number String into Primes in Java

← prev next →