A jumping number is defined as a positive number n which all pairs of consecutive decimal digits differ by 1. Also, all single digit numbers are considered jumping numbers. eg. 3, 45676, 212 are jumping numbers but 414 and 13 are not. The difference between 9 and 0 is not considered as 1

The challenge
Create a program that output one of the following results:

• Given an input n output the first n jumping numbers.


• Given an input n output the n^th term of the sequence.

Note

• Any valid I/O format is allowed


• 1-index or 0-index is allowed (please specify)

Here are some jumping numbers:

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, 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, ...

This is also A033075

C (gcc), 90 bytes

f(n,K,b,k){for(K=0;n;b&&printf("%d,",K,n--))for(b=k=++K;k/10;)b*=abs(k%10-(k/=10)%10)==1;}

Try it online!

Jelly, 8 bytes

1DI*`ƑƊ#

A full program accepting an integer, n, from STDIN which prints a list of the first n positive jumping numbers.

Try it online!

How?

Acceptable incremental differences between digits are 1 and -1 while others from [-9,-2]+[2,9] are not. This lines up with integers which are invariant when raised to themselves. i.e. $x^x=x$ since:

$$0^0=1$$
$$1^1=1$$
$$2^2=4$$
$$cdots$$
$$-1^{-1}=-1$$
$$-2^{-2}=-frac{1}{4}$$
$$cdots$$

1DI*`ƑƊ# - Main Link: no arguments (accepts a line of input from STDIN)

       # - count up keeping the first (input) n matches...

1        - ...start with n equal to: 1

      Ɗ  - ...match function: last three links as a monad:  e.g. 245       777      7656

 D       -   convert to a list of decimal digits                 [2,4,5]   [7,7,7]  [7,6,5,6]

  I      -   incremental differences                             [2,1]     [0,0]    [-1,-1,1]

     Ƒ   -   invariant under?:

    `    -     using left argument as both inputs of:

   *     -       exponentiation (vectorises)                     [4,1]     [1,1]    [-1,-1,1]

         -                                            --so we:   discard   discard  keep

         - implicitly print the list of collected values of n

Haskell, 61 bytes

f n|l<-map fromEnum.show$n=all((==1).abs)$zipWith(-)l(tail l)

Try it online!

Jelly, 10 bytes

1DạƝ=1ẠƲ³#

Try it online!

1-indexed.

JavaScript (ES7), 60 bytes

Returns the $n$^th term of the sequence (1-indexed).

f=(n,k)=>[...k+''].some(p=x=>(p-(p=x))**2-1)||n--?f(n,-~k):k

Try it online!

Japt, 18 bytes

Outputs the first n terms using 1-based indexing.

@_ì_äa âÃÉ}fXÄ}h9õ

Try it

@_ì_äa âÃÉ}fXÄ}h9õ     :Implicit input of integer U

                9õ     :Range [1,9]

@             }h       :Run the following function until that reaches length U,

                       :passing the last element as X each time,

                       :and pushing the output each time

            XÄ         :  Add 1 to X

 _        }f           :  Get the first integer >= to that that returns falsey (0)

  ì                    :    Split to digit array

   _                   :    Run through the following function and rejoin to integer

    äa                 :      Consecutive absolute differences

       â               :      Deduplicate

        Ã              :    End function

         É             :    Subtract 1

(I know, I know, I'm supposed to be taking a break but I'm in golf withdrawal!)