Haskell, 57 bytes

(l!!)

l=[1..9]++[x*10+t|x<-l,t<-[0..9],(mod x 10-t)^2==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

05AB1E (legacy), 5 bytes

The input is 1-indexed.

Code:

µN¥ÄP

Uses the 05AB1E encoding. Try it online!

Explanation

µ          # Get the nth number, starting from 0, such that...

   Ä       #   The absolute values

 N¥        #   Of the delta's of N

    P      #   Are all 1 (product function, basically acts as a reduce by AND)

Python 2, 79 75 bytes

-4 bytes by xnor

f=lambda n,i=1:n and-~f(n-g(i),i+1)

g=lambda i:i<10or i%100%11%9==g(i/10)>0

Try it online!

Derived from Chas Brown's answer. The helper function g(i) returns whether i is a jumping number. Iff the last two digits of a number n have absolute difference 1, then n%100%11 will be either 1 or 10, so n%100%11%9 will be 1.

APL (Dyalog Unicode), 36 bytes^SBCS

1-indexed. Thanks to dzaima for their help with golfing this.

Edit: -15 bytes from ngn.

1+⍣{∧/1=|2-/⍎¨⍕⍺}⍣⎕⊢0

Try it online!

Explanation

We have f⍣g⍣h, where, as ⍣ is an operator, APL translates this to (f⍣g)⍣h. (In contrast with functions where 2×3+1 is translated 2×(3+1))

1+⍣{...}⍣⎕⊢0  This is equivalent to 

               "do {check} we find the n-th integer that fulfils {check}"



1+⍣{...}   ⊢0  Start with 0 and keep adding 1s until the dfn 

               (our jumping number check in {}) returns true.

        ⍣⎕    We take input n (⎕) and repeat (⍣) the above n times 

               to get the n-th jumping number.



{∧/1=|2-/⍎¨⍕⍺}  The dfn that checks for jumping numbers.



         ⍎¨⍕⍺   We take the base-10 digits of our left argument

                 by evaluating each character of the string representation of ⍺.

     |2-/        Then we take the absolute value of the pairwise differences of the digits

 ∧/1=            and check if all of the differences are equal to 1.

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!

Japt, 14 bytes

Outputs the first nth term, 1-indexed.

_ì äa dÉ ªU´}f

Try it

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

Python 2, 88 87 bytes

f=lambda n,i=2:n and f(n-g(i),i+1)or~-i

g=lambda i:i<10or abs(i/10%10-i%10)==1==g(i/10)

Try it online!

Returns the 0-indexed jumping number (i.e., f(0) => 1, etc).

Haskell, 69 bytes

• Thanks to Joseph Sible for enforcing the challenge rules and saving three bytes.


• Saved two bytes thanks to nimi.

(filter(all((==1).abs).(zipWith(-)<*>tail).map fromEnum.show)[1..]!!)

Try it online!

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!

Jelly, 9 bytes

-1 by Jonathan Allan

1DạƝ=1ẠƲ#

Try it online!

1-indexed.

Swift, 228 bytes

func j(n:Int){

var r:[Int]=

for x in 0...n{

if x<=10{r.append(x)}else{

let t=String(x).compactMap{Int(String($0))}

var b=true

for i in 1...t.count-1{if abs(t[i-1]-t[i]) != 1{b=false}}

if b{r.append(x)}

}

}

print(r)

}

j(n:1000)

Try it online!

Python 3, 122 121 bytes

g=lambda s:len(s)==1or 1==abs(ord(s[0])-ord(s[1]))and g(s[1:])

def f(n,i=1):

	while n:

		if g(str(i)):n-=1;yield i

		i+=1

Try it online!

-1 byte by changing f from printing, to a generator function.

g is a recursive helper function which determines if a string s is a "jumping string" (this works since the character codes for 0 to 9 are in order and contiguous).

f is a generator function that takes in n and yields the first n jumping numbers.

R, 85 bytes

i=scan();j=0;while(i)if((j=j+1)<10|all(abs(diff(j%/%10^(0:log10(j))%%10))==1))i=i-1;j

Try it online!

Suspect this can be golfed more. Reads the number using scan() and outputs the appropriate jumping number.

Perl 5, 56 bytes

map{1while++$n=~s|.(?=(.))|abs$&-$1!=1|ger>9}1..<>;say$n

Try it online!

1-indexed, outputs the n^th jumping number

Wolfram Language (Mathematica), 85 bytes

If[#<10,#,t=n=1;While[t<=#,{-1,1}~SubsetQ~Differences@IntegerDigits@n++~If~t++];n-1]&

Try it online!

returns the n-th number

Factor, 129 bytes

: f ( x -- ) 1 [ [ dup 10 >base >array differences [ abs 1 = ] all? ] [ 1 + ] until

dup . 1 + [ 1 - ] dip over 0 > ] loop 2drop ;

Try it online!

Outputs the first n jumping numbers

Catholicon, 5 bytes

ρHṘḃǰ

Try it online!