A number is called as a Jumping Number if all adjacent digits in it differ by 1. The difference between ‘9’ and ‘0’ is not considered as 1.

All single digit numbers are considered as Jumping Numbers. For example 7, 8987 and 4343456 are Jumping numbers but 796 and 89098 are not.

Given a positive number x, print all Jumping Numbers smaller than or equal to x. The numbers can be printed in any order.

Example:

Input: x = 20 Output: 0 1 2 3 4 5 6 7 8 9 10 12 Input: x = 105 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 Note: Order of output doesn't matter, i.e. numbers can be printed in any order

## We strongly recommend that you click here and practice it, before moving on to the solution.

One **Simple Solution** is to traverse all numbers from 0 to x. For every traversed number, check if it is a Jumping number. If yes, then print it. Otherwise ignore it. Time Complexity of this solution is O(x).

An **Efficient Solution** can solve this problem in O(k) time where k is number of Jumping Numbers smaller than or equal to x. The idea is use BFS or DFS.

Assume that we have a graph where the starting node is 0 and we need to traverse it from the start node to all the reachable nodes.

With the restrictions given in the graph about the jumping numbers, what do you think should be the restrictions defining the next transitions in the graph.

Lets take a example for input x = 90 Start node = 0 From 0, we can move to 1 2 3 4 5 6 7 8 9 [these are not in our range so we don't add it] Now from 1, we can move to 12 and 10 From 2, 23 and 21 From 3, 34 and 32 . . . . . . and so on.

Below is BFS based implementation of above idea.

## C++

`// Finds and prints all jumping numbers smaller than or` `// equal to x.` `#include <bits/stdc++.h>` `using` `namespace` `std;` ` ` `// Prints all jumping numbers smaller than or equal to x starting` `// with 'num'. It mainly does BFS starting from 'num'.` `void` `bfs(` `int` `x, ` `int` `num)` `{` ` ` `// Create a queue and enqueue 'i' to it` ` ` `queue<` `int` `> q;` ` ` `q.push(num);` ` ` ` ` `// Do BFS starting from i` ` ` `while` `(!q.empty()) {` ` ` `num = q.front();` ` ` `q.pop();` ` ` ` ` `if` `(num <= x) {` ` ` `cout << num << ` `" "` `;` ` ` `int` `last_dig = num % 10;` ` ` ` ` `// If last digit is 0, append next digit only` ` ` `if` `(last_dig == 0)` ` ` `q.push((num * 10) + (last_dig + 1));` ` ` ` ` `// If last digit is 9, append previous digit only` ` ` `else` `if` `(last_dig == 9)` ` ` `q.push((num * 10) + (last_dig - 1));` ` ` ` ` `// If last digit is neighter 0 nor 9, append both` ` ` `// previous and next digits` ` ` `else` `{` ` ` `q.push((num * 10) + (last_dig - 1));` ` ` `q.push((num * 10) + (last_dig + 1));` ` ` `}` ` ` `}` ` ` `}` `}` ` ` `// Prints all jumping numbers smaller than or equal to` `// a positive number x` `void` `printJumping(` `int` `x)` `{` ` ` `cout << 0 << ` `" "` `;` ` ` `for` `(` `int` `i = 1; i <= 9 && i <= x; i++)` ` ` `bfs(x, i);` `}` ` ` `// Driver program` `int` `main()` `{` ` ` `int` `x = 40;` ` ` `printJumping(x);` ` ` `return` `0;` `}` |

## Java

`// Finds and prints all jumping numbers smaller than or` `// equal to x.` `import` `java.util.*;` `import` `java.lang.*;` `import` `java.io.*;` ` ` `class` `GFG {` ` ` ` ` `// Prints all jumping numbers smaller than or equal to x starting` ` ` `// with 'num'. It mainly does BFS starting from 'num'.` ` ` `public` `void` `bfs(` `int` `x, ` `int` `num)` ` ` `{` ` ` `// Create a queue and enqueue 'i' to it` ` ` `Queue<Integer> q = ` `new` `LinkedList<Integer>();` ` ` `q.add(num);` ` ` ` ` `// Do BFS starting from i` ` ` `while` `(!q.isEmpty()) {` ` ` `num = q.peek();` ` ` `q.poll();` ` ` `if` `(num <= x) {` ` ` `System.out.print(num + ` `" "` `);` ` ` `int` `last_digit = num % ` `10` `;` ` ` ` ` `// If last digit is 0, append next digit only` ` ` `if` `(last_digit == ` `0` `) {` ` ` `q.add((num * ` `10` `) + (last_digit + ` `1` `));` ` ` `}` ` ` ` ` `// If last digit is 9, append previous digit only` ` ` `else` `if` `(last_digit == ` `9` `) {` ` ` `q.add((num * ` `10` `) + (last_digit - ` `1` `));` ` ` `}` ` ` ` ` `// If last digit is neighter 0 nor 9, append both` ` ` `// previous and next digits` ` ` `else` `{` ` ` `q.add((num * ` `10` `) + (last_digit - ` `1` `));` ` ` `q.add((num * ` `10` `) + (last_digit + ` `1` `));` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` ` ` `// Prints all jumping numbers smaller than or equal to` ` ` `// a positive number x` ` ` `public` `void` `printJumping(` `int` `x)` ` ` `{` ` ` `System.out.print(` `"0 "` `);` ` ` ` ` `for` `(` `int` `i = ` `1` `; i <= ` `9` `&& i <= x; i++) {` ` ` `this` `.bfs(x, i);` ` ` `}` ` ` `}` ` ` ` ` `// Driver program` ` ` `public` `static` `void` `main(String[] args) ` `throws` `IOException` ` ` `{` ` ` `int` `x = ` `40` `;` ` ` `GFG obj = ` `new` `GFG();` ` ` `obj.printJumping(x);` ` ` `}` `}` |

## Python 3

`# Class queue for use later` `class` `Queue:` ` ` `def` `__init__(` `self` `):` ` ` `self` `.lst ` `=` `[]` ` ` ` ` `def` `is_empty(` `self` `):` ` ` `return` `self` `.lst ` `=` `=` `[]` ` ` ` ` `def` `enqueue(` `self` `, elem):` ` ` `self` `.lst.append(elem)` ` ` ` ` `def` `dequeue(` `self` `):` ` ` `return` `self` `.lst.pop(` `0` `)` ` ` `# Prints all jumping numbers smaller than or equal to` `# x starting with 'num'. It mainly does BFS starting` `# from 'num'.` `def` `bfs(x, num):` ` ` ` ` `# Create a queue and enqueue i to it` ` ` `q ` `=` `Queue()` ` ` `q.enqueue(num)` ` ` ` ` `# Do BFS starting from 1` ` ` `while` `(` `not` `q.is_empty()):` ` ` `num ` `=` `q.dequeue()` ` ` ` ` `if` `num<` `=` `x:` ` ` `print` `(` `str` `(num), end ` `=` `' '` `)` ` ` `last_dig ` `=` `num ` `%` `10` ` ` ` ` `# If last digit is 0, append next digit only` ` ` `if` `last_dig ` `=` `=` `0` `:` ` ` `q.enqueue((num ` `*` `10` `) ` `+` `(last_dig ` `+` `1` `))` ` ` ` ` `# If last digit is 9, append previous digit` ` ` `# only` ` ` `elif` `last_dig ` `=` `=` `9` `:` ` ` `q.enqueue((num ` `*` `10` `) ` `+` `(last_dig ` `-` `1` `))` ` ` ` ` `# If last digit is neighter 0 nor 9, append` ` ` `# both previous digit and next digit` ` ` `else` `:` ` ` `q.enqueue((num ` `*` `10` `) ` `+` `(last_dig ` `-` `1` `))` ` ` `q.enqueue((num ` `*` `10` `) ` `+` `(last_dig ` `+` `1` `))` ` ` `# Prints all jumping numbers smaller than or equal to` `# a positive number x` `def` `printJumping(x):` ` ` `print` `(` `str` `(` `0` `), end ` `=` `' '` `)` ` ` `for` `i ` `in` `range` `(` `1` `, ` `10` `):` ` ` `bfs(x, i)` ` ` `# Driver Program ( Change value of x as desired )` `x ` `=` `40` `printJumping(x)` ` ` `# This code is contributed by Saket Modi` |

## C#

`// C# program to finds and prints all jumping ` `// numbers smaller than or equal to x.` `using` `System;` `using` `System.Collections.Generic;` ` ` `class` `GFG ` `{` ` ` ` ` `// Prints all jumping numbers smaller than or ` ` ` `// equal to x starting with 'num'. It mainly` ` ` `// does BFS starting from 'num'.` ` ` `public` `void` `bfs(` `int` `x, ` `int` `num)` ` ` `{` ` ` `// Create a queue and enqueue 'i' to it` ` ` `Queue<` `int` `> q = ` `new` `Queue<` `int` `>();` ` ` `q.Enqueue(num);` ` ` ` ` `// Do BFS starting from i` ` ` `while` `(q.Count!=0) ` ` ` `{` ` ` `num = q.Peek();` ` ` `q.Dequeue();` ` ` `if` `(num <= x) ` ` ` `{` ` ` `Console.Write(num + ` `" "` `);` ` ` `int` `last_digit = num % 10;` ` ` ` ` `// If last digit is 0, append next digit only` ` ` `if` `(last_digit == 0) ` ` ` `{` ` ` `q.Enqueue((num * 10) + (last_digit + 1));` ` ` `}` ` ` ` ` `// If last digit is 9, append previous digit only` ` ` `else` `if` `(last_digit == 9) ` ` ` `{` ` ` `q.Enqueue((num * 10) + (last_digit - 1));` ` ` `}` ` ` ` ` `// If last digit is neighter 0 nor 9, append both` ` ` `// previous and next digits` ` ` `else` ` ` `{` ` ` `q.Enqueue((num * 10) + (last_digit - 1));` ` ` `q.Enqueue((num * 10) + (last_digit + 1));` ` ` `}` ` ` `}` ` ` `}` ` ` `}` ` ` ` ` `// Prints all jumping numbers smaller than or equal to` ` ` `// a positive number x` ` ` `public` `void` `printJumping(` `int` `x)` ` ` `{` ` ` `Console.Write(` `"0 "` `);` ` ` ` ` `for` `(` `int` `i = 1; i <= 9 && i <= x; i++) ` ` ` `{` ` ` `this` `.bfs(x, i);` ` ` `}` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `Main(String[] args) ` ` ` `{` ` ` `int` `x = 40;` ` ` `GFG obj = ` `new` `GFG();` ` ` `obj.printJumping(x);` ` ` `}` `}` ` ` `// This code has been contributed by 29AjayKumar` |

**Output:**

0 1 10 12 2 21 23 3 32 34 4 5 6 7 8 9

Thanks to Gaurav Ahirwar for above solution.

**Exercise:**

- Change the above solution to use DFS instead of BFS.
- Extend your solution to print all numbers in sorted order instead of any order.
- Further extend the solution to print all numbers in a given range.

If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**