Jumping Number in Java

In this section, we will learn what is jumping number and also create Java programs to check if the given number is a jumping number or not. The jumping number program frequently asked in Java coding tests and academics.

Jumping Number

A number N called a jumping number if all the adjacent digits in N have an absolute difference of 1. Note that the difference between 9 and 0 is not considered as 1. Therefore, all single-digit number is considered as a jumping number.

Jumping Number Example

For example, the number 76789 is a jumping number because each adjacent digit has the difference of 1.

The number 952 is not a jumping number because the adjacent digit has a difference of 4 and 3, respectively.

Some other jumping numbers are 45676, 212, 121, 123, 210, 212, 232, 234, 321, 323, 343, 345, 432, 434, 454, 456, 543, 545, 565, 567, 654, 656, 676, 678, 765, 767, 787, 789, 876, etc.

Steps to Find Jumping Number

Read or initialize a number N.
Iterate over the integers, 0 to N.
For each integer, iterate over its digits.
- Check if the current digit and the previous digit differ by 1.
If all the adjacent digits in the current integer differ by 1, add the integer to the list of jumping numbers.

Let's implement the above logic in a Java program.

Jumping Number Java Program

JumpingNumberExample1.java

import java.util.*;
public class JumpingNumberExample1
{
public static void main(String args[])
{
int num, difference=0;  
boolean flag = true;
Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
//reads an integer from the user
num=sc.nextInt();
//assigning num to n
int n = num;
//execute until the condition becomes false
while(num != 0)
{
//determines the last digit from the given number    
int digit1 = num % 10;
//removes the last digit 
num = num/10;
//checks if the number is equal to 0 or not
if(num != 0)
{
//if the above condition returns true
//determines the second last digit from the number
int digit2 = num % 10;
//subtract the digits and finds the absolute value
//after that checks if the difference of two adjacent digit is equal to 1 or not
if(Math.abs(digit1 - digit2) != 1)
{
//if the difference is not equal to 1, set flag to false    
flag = false;
//breaks the execution
break;
}//end of if 2nd statement 
}//end of if 1st statement 
}//end of while
if(flag)
System.out.println(n + " is a jumping number.");
else
System.out.println(n + " is not a jumping number.");
}
}

Output 1:

Enter a number: 121
121 is a jumping number.

Output 2:

Enter a number: 7839
7839 is not a jumping number.

Print All Jumping Numbers Between Given Range

There are two ways to print all jumping numbers within a given range:

By Using DFS
By Using BFS

By using DFS

In DFS, we do not check every integer, instead we print directly all the jumping numbers. In order to achieve the same, we start with the first jumping number i.e. 0 and append a new digit to it such that the difference between the next and the previous digit is 1.

Note that if the previous digit is 0, the only possible next digit will be 1 that gives the next jumping number i.e. 1. Similarly, for digit 9 the only possible next digit is 8, not 10. But for the numbers 1 to 8, we'll always have two options for next digits (one less and other greater than it).

The above process is repeated with 1. At this point, we have two possible options for the next digit i.e. 2 and 0 that generates the two new jumping numbers i.e. 12 and 10.

In this approach, we assume that the numbers as the nodes of the graph. Let's see the steps implemented in DFS.

The above approach can be implemented by assuming the numbers as the nodes of the graph.
Starting with node '0', apply DFS on the graph.
Base Condition: If the generated node or number is greater than N, stop the traversal for that node and return.
Add the current node or number in the jumping list if the number is less than N.
Now, to transit from one node to next, append digits to the current node such that the next number generated is also a jumping number and then recursively call DFS on the next node.
If we want to generate all the jumping numbers, repeat the above algorithm by taking the remaining integers 2-9 as the starting nodes.
At last, sort the list of jumping numbers and return the same.

Let's implement the above approach in a Java program.

JumpingNumberExample2.java

import java.util.*;
public class JumpingNumberExample2
{
public static void main(String[] args) 
{
int num = 104;
Set<Integer> set = new HashSet<>();
for(int i=0;i<10;i++) 
{
dfs(num, set, i);
}
List<Integer> res = new ArrayList<>(set);
//sorts the array
Collections.sort(res);
//prints the elements of the array after sorting
System.out.println(res);
}
static void dfs(int num, Set<Integer> res, int tmp) 
{
if(tmp > num)
return;
if(!res.add(tmp))
return;
if(tmp%10 == 0) 
{
dfs(num, res, tmp * 10 + 1);
}
else if(tmp%10 == 9) 
{
dfs(num, res, tmp * 10 + 8);
}
else 
{
dfs(num, res, tmp * 10 + tmp%10 - 1);
dfs(num, res, tmp * 10 + tmp%10 + 1);
}
}
}

Output:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 21, 23, 32, 34, 43, 45, 54, 56, 65, 67, 76, 78, 87, 89, 98, 101]

Let's see another logic for the same but in the following program we have not used DFS.

JumpingNumberExample3.java

public class JumpingNumberExample3
{
//function that checks if the number is a jumping number or not    
private static boolean isJumpingNumber(int n) 
{
//takes the number n, convert it into String, and split the number into digits    
//after that creates an array of digits
String []digits = new Integer(n).toString().split("");
//loop starts from the 0 and executes till the length of array-1
for(int i=0; i < digits.length-1; i++)
{
//picks the ith element and convert it into integer    
int digit1 = Integer.valueOf(digits[i]);
//picks the i+1th element and convert it into integer  
int digit2 = Integer.valueOf(digits[i+1]);
//checks if the difference of two adjacent digit is equal to 1 or not
if (Math.abs(digit1-digit2) != 1) 
//if not equal, returns false
return false; 
}
//if equal, returns false
return true;
}
//function prints all the jumping numbers for a given range
private static void printJumpingNumbers(int n) 
{
System.out.println("Jumping numbers for specified range are: ");   
for(int i=0; i <=n; i++) 
{
//calling the user-defined function    
if(isJumpingNumber(i)) 
{
//prints the jumping number    
System.out.print(i+ ", ");
}
}    
}
//driver code
public static void main(String args[]) 
{
//calling the user-defined function and passing the range as a parameter    
printJumpingNumbers(200);
}
}

Output:

Jumping numbers for specified range are: 
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 21, 23, 32, 34, 43, 45, 54, 56, 65, 67, 76, 78, 87, 89, 98, 101, 121, 123

By Using BFS

The approach is similar to the DFS. But instead of using DFS, we can also use BFS to generate the graph. Let's see the approach.

Initialize an empty queue.
Push the starting node i.e. '0' in the queue.
Repeat the following steps until the queue becomes empty:
1. Pop the top node from the queue that will be the current node.
2. If the current node (number) is less than or equal to N, add it to the list of jumping numbers.
3. And generate the next node by appending digits to the current node such that the next number (node) generated is also a jumping number. And push the number into the queue.
4. Else, move to the next node in the queue.
In order to generate all the jumping numbers, repeat the above algorithm by taking the remaining integers 2-9 as the starting nodes.
At last, sort the list of jumping numbers and return the same.

Let's implement the above approach in a Java program.

JumpingNumberExample4.java

import java.util.*;
import java.lang.*;
import java.io.*;
public class JumpingNumberExample4
{
//function prints all jumping numbers smaller than or equal to x starting
public void isJumping(int x, int num)
{
//creates a queue of integer type
Queue<Integer> que = new LinkedList<Integer>();
//inserts the specified element into the queue
que.add(num);
//do BFS starting from i
//while loop executes until the queue becomes empty
while (!que.isEmpty()) 
{
//the peek() method of the Queue class retrieves, but does not remove, the head of the queue,   
num = que.peek();
//the poll() method of the Queue class retrieves and removes the head of the queue
que.poll();
//executes until the condition becomes false
if (num <= x) 
{
System.out.print(num + " ");
int lstdigit = num % 10;
//checks if the last digit is 0 or not
if (lstdigit == 0) 
{
//if the last digit is 0, append the next digit only       
que.add((num * 10) + (lstdigit + 1));
}//end of if
//checks if the last digit is 9 or not
else if (lstdigit == 9) 
{
//if the last digit is 9, append the previous digit only   
que.add((num * 10) + (lstdigit - 1));
}//end of else-if
//executes if the last digit is neither 0 nor 9
//append both previous and next digit
else 
{
//appends the previous digit    
que.add((num * 10) + (lstdigit - 1));
//appends the next digit
que.add((num * 10) + (lstdigit + 1));
}//end of else
}//end of if
}//end of while
}
//prints all the jumping numbers that are smaller than or equal to x
public void printJumpingNumber(int x)
{
System.out.println("Jumping numbers for specified range are: ");       
System.out.print("0 ");
for (int i = 1; i <= 9 && i <= x; i++) 
{
//calling a user-defined function that checks if the given number is jumping or not    
this.isJumping(x, i);
}
}
//driver code
public static void main(String args[])
{
int x = 500;
JumpingNumberExample4 jn = new JumpingNumberExample4();
//invokes the user-defined function that prints all the jumping numbers
jn.printJumpingNumber(x);
}
}

Output:

Jumping numbers for specified range are: 
0 1 10 12 101 121 123 2 21 23 210 212 232 234 3 32 34 321 323 343 345 4 43 45 432 434 454 456 5 54 56 6 65 67 7 76 78 8 87 89 9 98

Next TopicLead Number in Java

← prev next →