Jumping Number in Java

2025 年 5 月 6 日 | 阅读 7 分钟

在本节中，我们将学习什么是跳跃数，并创建 Java 程序 来检查给定的数字是否为跳跃数。跳跃数程序经常在 Java 编码测试和学术中出现。

跳跃数

如果数字 N 的所有相邻数字的绝对差为 1，则称 N 为跳跃数。请注意，9 和 0 之间的差不被视为 1。因此，所有个位数都被视为跳跃数。

跳跃数示例

例如，数字 76789 是一个跳跃数，因为每个相邻数字的差为 1。

数字 952不是跳跃数，因为相邻数字的差分别为 4 和 3。

其他跳跃数有 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 等。

查找跳跃数的步骤

读取或初始化一个数字 N。
迭代整数，从 0 到 N。
对于每个整数，迭代其各位数字。
- 检查当前数字和前一个数字的差是否为 1。
如果当前整数的所有相邻数字都相差 1，则将该整数添加到跳跃数列表中。

让我们在 Java 程序中实现上述逻辑。

跳跃数 Java 程序

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.");
}
}

输出 1

Enter a number: 121
121 is a jumping number.

输出 2

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

打印给定范围内的所有跳跃数

有两种方法可以打印给定范围内的所有跳跃数

使用 DFS
使用 BFS

使用 DFS

在 DFS 中，我们不检查每个整数，而是直接打印所有跳跃数。为了实现这一点，我们从第一个跳跃数即 0 开始，并为其附加一个新数字，使下一个数字和前一个数字之间的差为 1。

请注意，如果前一位数字是 0，则唯一可能的下一个数字是 1，这将生成下一个跳跃数，即 1。类似地，对于数字 9，唯一可能的下一个数字是 8，而不是 10。但是对于数字 1 到 8，我们总是有两个下一个数字的选项（一个小于它，一个大于它）。

上述过程以 1 重复。此时，下一个数字有两个可能的选项，即 2 和 0，它们生成两个新的跳跃数，即 12 和 10。

在这种方法中，我们将数字视为图的节点。让我们看看 DFS 中实现的步骤。

上述方法可以通过将数字视为图的节点来实现。
从节点 '0' 开始，在图上应用 DFS。
基本条件：如果生成的节点或数字大于 N，则停止该节点的遍历并返回。
如果数字小于 N，则将当前节点或数字添加到跳跃列表中。
现在，要从一个节点转移到下一个节点，请在当前节点后面附加数字，以便生成的下一个数字也是一个跳跃数，然后递归调用 DFS 到下一个节点。
如果我们想生成所有跳跃数，则通过将剩余的整数 2-9 作为起始节点来重复上述算法。
最后，对跳跃数列表进行排序并返回。

让我们在 Java 程序中实现上述方法。

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);
}
}
}

输出

[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]

让我们来看一个相同的程序，但在下面的程序中我们没有使用 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);
}
}

输出

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

使用 BFS

该方法与 DFS 类似。但是，除了使用 DFS，我们还可以使用 BFS 来生成图。让我们来看看这个方法。

初始化一个空队列。
将起始节点即 '0' 推入队列。
重复以下步骤，直到队列为空
1. 从队列中弹出顶部节点，这将是当前节点。
2. 如果当前节点（数字）小于或等于 N，则将其添加到跳跃数列表中。
3. 并通过在当前节点后面附加数字来生成下一个节点，以便生成的下一个数字（节点）也是一个跳跃数。然后将该数字推入队列。
4. 否则，移动到队列中的下一个节点。
为了生成所有跳跃数，通过将剩余的整数 2-9 作为起始节点来重复上述算法。
最后，对跳跃数列表进行排序并返回。

让我们在 Java 程序中实现上述方法。

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);
}
}

输出

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

下一主题计算 Java 中圆盘序列的交点数

Jumping Number in Java

跳跃数

跳跃数示例

查找跳跃数的步骤

跳跃数 Java 程序

打印给定范围内的所有跳跃数

使用 DFS

使用 BFS

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Jumping Number in Java

跳跃数

跳跃数示例

查找跳跃数的步骤

跳跃数 Java 程序

打印给定范围内的所有跳跃数

使用 DFS

使用 BFS

相关帖子

如何在 ArrayList Java 中添加日期

Java Get Post

Remove Loop in Linked List Using Java

Java Coding Software

Java 中链表操作是什么

JDoodle Java

Detect Cycle in a Directed Graph in Java

Java 中集合位计数最多为 K 的最大整数

Java 中的图像处理：将彩色图像转换为红色、绿色和蓝色图像

Java 9 Optional 类改进

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器