# Definition

**_Jumping number_** is the number that *All adjacent digits in it differ by 1*.

____

# Task

**_Given_** a number, **_Find if it is Jumping or not_** . 
____

# Warm-up (Highly recommended)

# [Playing With Numbers Series](https://www.codewars.com/collections/playing-with-numbers)
___

# Notes 

* **_Number_** *passed is always*  **_Positive_** .

* **_Return_** *the result as* **_String_** . 

* **_The difference between_** *‘9’ and ‘0’* is **_not considered as 1_** . 

* **_All single digit numbers_** are considered as **_Jumping numbers_**. 
___

# Input >> Output Examples

```
jumpingNumber(9) ==> return "Jumping!!"
```
## **_Explanation_**:

* It's  **_single-digit number_** 
___

```
jumpingNumber(79) ==> return "Not!!"
```

## **_Explanation_**:

* *Adjacent digits* **_don't differ by 1_**
___

```
jumpingNumber(23) ==> return "Jumping!!"
```

## **_Explanation_**:

* *Adjacent digits* **_differ by 1_**
___

```
jumpingNumber(556847) ==> return "Not!!"
```

## **_Explanation_**:

* *Adjacent digits* **_don't differ by 1_**
___

```
jumpingNumber(4343456) ==> return "Jumping!!"
```

## **_Explanation_**:

* *Adjacent digits* **_differ by 1_**
___

```
jumpingNumber(89098) ==> return "Not!!"
```

## **_Explanation_**:

* *Adjacent digits* **_don't differ by 1_**
___

```
jumpingNumber(32) ==> return "Jumping!!"
```

## **_Explanation_**:

* *Adjacent digits* **_differ by 1_**
___
___
___

# [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers)

# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)

# [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored)
___

## ALL translations are welcomed

## Enjoy Learning !!
# Zizou

Difficulty: introductory

Starter code:

def jumping_number(number):
	

Solutions:
def jumping_number(number):
    arr = list(map(int, str(number)))
    return ('Not!!', 'Jumping!!')[all(map(lambda a, b: abs(a - b) == 1, arr, arr[1:]))]

def jumping_number(number):
    digits = [int(char) for char in str(number)]
    if len(digits) == 1:
        return 'Jumping!!'
    else:
        deltas = (abs(x - y) for x, y in zip(digits, digits[1:]))
        return 'Jumping!!' if all(delta == 1 for delta in deltas) else 'Not!!'

def jumping_number(number):
    digits = [int(n) for n in list(str(number))]
    for i in range(len(digits)-1):
        if abs(digits[i] - digits[i+1]) != 1:
            return 'Not!!'
    return 'Jumping!!'

def jumping_number(number):
    lst = list(map(int, str(number)))
    return "Jumping!!" if len(lst) == 1 or {1} == {abs(b-a) for a,b in zip(lst, lst[1:])} else "Not!!"

def jumping_number(number):
    return 'Jumping!!' if all(abs(int(a) - int(b)) == 1 for a, b in zip(str(number), str(number)[1:])) else 'Not!!'

def jumping_number(n):
    s = str(n)
    return "Jumping!!" if all(s[i:i+2] in "0123456789876543210" for i in range(len(s))) else "Not!!"

def jumping_number(number):
    s = str(number)
    return next(('Not!!' for a,b in zip(s, s[1:]) if abs(int(b)-int(a)) != 1), 'Jumping!!')

def jumping_number(number):
    s = str(number)
    return ('Not!!', 'Jumping!!')[all(0 for a,b in zip(s, s[1:]) if abs(int(b)-int(a)) != 1)]

from numpy import diff

def jumping_number(number):
    return "Jumping!!" if all([abs(x) == 1 for x in diff([int(x) for x in str(number)])]) else "Not!!"

def jumping_number(number):
  j = lambda n: n<10 or abs(n%10-(n//10)%10)==1 and j(n//10)
  return 'Jumping!!' if j(number) else 'Not!!'

def jumping_number(number):

    if number < 10: return "Jumping!!"
    
    n = list(map(int, str(number)))
    
    for a in zip(n,n[1:]):
        if abs(a[0]-a[1]) != 1: return "Not!!" 
    
    return "Jumping!!"
    


def jumping_number(number):
    list = ([int(d) for d in str(number)])
    diffList = []

    for i in range(1, len(list)):
        diff = (list[i] - (list[i-1]))
        if diff == 1 or diff == -1:
            diffList.append("Jumping!!")
        else:
            diffList.append("Not!!")


    if "Not!!" in diffList:
        return("Not!!")
    else:
        return("Jumping!!")

def jumping_number(number):
    string_n = str(number)
    l = len(string_n)
    if l <= 1: return "Jumping!!"
    else:
        for i in range(l-1):
            if abs(int(string_n[i]) - int(string_n[i+1])) != 1: return "Not!!"
    return "Jumping!!"

jumping_number=lambda n:['Not!!','Jumping!!'][all(abs(ord(a)-ord(b))==1for a,b in zip(str(n),str(n)[1:]))]

def jumping_number(number):
    ls = list(map(int, str(number)))
    for i in range(len(ls) - 1):
        if ls[i + 1] != ls[i] + 1 and ls[i + 1] != ls[i] - 1:
            return 'Not!!'
    return 'Jumping!!'

def jumping_number(number):
    numbers = [int(i) for i in str(number)]    
    for i in range(1, len(numbers)):
        if abs(numbers[i-1]-numbers[i]) == 1:
            continue
        else:
            return "Not!!"
            
    return "Jumping!!"


def jumping_number(number):
    str_list = list(str(number))
    length = len(str_list)
    if length == 1:
        choose = 'Jumping!!'
    elif length == 2:
        if abs(int(str_list[0]) - int(str_list[1])) == 1:
            choose = 'Jumping!!'
        else:
            choose = 'Not!!'
    else:
        for i in range(len(str_list)-1):
            if abs(int(str_list[i]) - int(str_list[i+1])) != 1:
                choose = 'Not!!'
                break
            else:
                choose = 'Jumping!!'
    return choose
                


def jumping_number(number):
    number = [int(i) for i in str(number)]
    return "Jumping!!" if all(abs(a-b) == 1 for a, b in zip(number, number[1::])) else "Not!!"

def jumping_number(number):
    arr_number=[int(i) for i in str(number)]
    for x in range(len(arr_number)-1):  
        if abs(arr_number[x] - arr_number[x+1]) !=1: 
            return "Not!!"      
    return "Jumping!!"

def jumping_number(number):
    numbers = [int(a) for a in str(number)]    
    for a in range(1, len(numbers)):
        if abs(numbers[a-1]-numbers[a]) == 1:
            continue
        else:
            return "Not!!"
            
    return "Jumping!!"

def jumping_number(number):
    numbers = [int(x) for x in str(number)]
    diff = [numbers[i+1]-numbers[i] for i in range(len(numbers) - 1)]
    if (diff.count(1) + diff.count(-1) == len(numbers) - 1) or (len(diff) == 0):
        return "Jumping!!"
    else:
        return "Not!!"

def jumping_number(n):
    if n < 10: return "Jumping!!"
    for i in range(len(str(n)) - 1):
        if int(str(n)[i + 1]) not in [int(str(n)[i]) + 1, int(str(n)[i]) - 1]: return "Not!!"
    return "Jumping!!"

def jumping_number(number):
    num_list = list(map(int,list(str(number))))
    for i in range(1,len(num_list)):
        if abs(num_list[i] - num_list[i-1]) != 1:
            return "Not!!"
    return "Jumping!!"

def jumping_number(number):
    if len(str(number)) == 1:
        return "Jumping!!"

    else:
        number = str(number)
        for n in range(1,len(number)):
            if abs(int(number[n]) - int(number[n-1])) != 1:
                return "Not!!"

        return "Jumping!!"


def jumping_number(n):
    l=len(str(n))
    if l==1:
        return "Jumping!!"
    x=[int(x) for x in str(n)]
    return "Jumping!!" if all   (   abs( x[i+1] -x[i] ) ==1   for i in range(l-1) ) else 'Not!!'

def jumping_number(n):
    s = str(n)
    return ['Not!!', 'Jumping!!'] [all(abs(int(d1)-int(d2))==1 for d1, d2 in zip(s[:-1], s[1:]))]

def jumping_number(number):
    number = [int(i) for i in str(number)]
    for i in range(len(number)-1):
        if not abs(number[i]-number[i+1])==1:
            return 'Not!!'
        
    return 'Jumping!!'


def jumping_number(number):
    for i in range(len(str(number))-1) :
        if abs(int(str(number)[i+1])-int(str(number)[i]))!=1 : break
    else : return "Jumping!!"
    return "Not!!"


def jumping_number(number):
    numero = str(number)
    res = []
    if len(numero) == 1:
        return "Jumping!!"
    else:
        for i in range(len(numero)-1): 
            if (int(numero[i]) - int(numero[i + 1])) == 1 or (int(numero[i]) - int(numero[i + 1])) == -1:
                res.append(0)   
            else:
                res.append(1)
            
    if sum(res) == 0:
        return "Jumping!!"
    else:
        return "Not!!"

def jumping_number(number): #poor kata...
    return ['Not!!', 'Jumping!!'][number in [1, 7, 9, 23, 32, 98, 8987, 4343456, 98789876]]

def jumping_number(number):
    s=str(number)
    return 'Jumping!!' if all(abs(int(x)-int(y))==1 for x,y in zip(s[:-1],s[1:])) else 'Not!!'

def jumping_number(number):
    pass
    
    if number<10:
        
        return "Jumping!!"
    
    n = [int(x) for x in str(number)]
    
    l = len(n)
    
    a = []
    
    for x,y in zip(n[0::],n[1::]):
        
        s = abs(x-y)
        
        a.append(s)
               
    if all(j==1 for j in a):
              
        return "Jumping!!"
                    
    else:
                
        return "Not!!"


def jumping_number(number):
    number = str(number)
    for i in range(1, len(number)):
        if abs(int(number[i - 1]) - int(number[i])) != 1:
            return "Not!!"
    return "Jumping!!"

def jumping_number(number):
    l = [int(i) for i in str(number)]
    if len(l) == 1:
        return 'Jumping!!'
    prev = l[0] - 1
    for i in l:
        if abs(i - prev) != 1:
            return 'Not!!'
        prev = i
    return 'Jumping!!'

def jumping_number(number):
    #if len(str(number)) == 1:
    #    return 'Jumping!!'
    
    for i in range(1, len(str(number))):
        if abs(int(str(number)[i]) - int(str(number)[i-1])) != 1:
            return 'Not!!'
    
    return 'Jumping!!'

def jumping_number(number):
    x = str(number)
    if len(str(number)) == 1:
           return 'Jumping!!'
    else:
        for i in range(len(x)-1):
            if abs(int(x[i]) - int(x[i+1])) == 1:
                continue
            else:
                return 'Not!!'
        return 'Jumping!!'

def jumping_number(number):
    
    a = []
    
    if number < 10:
        return "Jumping!!"
    
    for i in str(number):
        a.append(int(i))
    
    for i in range(1, len(a)):
        if a[i-1] - a[i] == 1 or a[i-1] - a[i] == -1:
            pass
        else:
            return "Not!!"
        
    return "Jumping!!"

def jumping_number(number):
    print(number)
    a=[int(x) for x in list(str(number))]
    print(a) 
    if len(a)<2:
        return 'Jumping!!'
    return'Jumping!!' if all( a[i]==a[i+1]-1 or a[i]==a[i+1]+1 for i in range(len(a)-1 ))else'Not!!'

def jumping_number(number):
    st = str(number)
    if len(st) == 1:
        return "Jumping!!"
    for i,c in enumerate(st):
        if i == 0:
            continue
        if int(c) != int(st[i-1]) + 1:
            if int(c) != int(st[i-1]) - 1:
                return "Not!!"
        
    return "Jumping!!"


def jumping_number(number):
    if(len(str(number))>1):
        jumping=True
        for i in range(1,len(str(number))):
            if(not abs(int(str(number)[i])-int(str(number)[i-1]))==1):
                jumping=False
    else:
        jumping=True
    if(jumping):
        return "Jumping!!"
    else:
        return "Not!!"

def jumping_number(n):
    for i in range(len(str(n))-1):
        if abs(int(str(n)[i])-int(str(n)[i+1])) != 1:
            return "Not!!"
    return "Jumping!!"

def jumping_number(number):
    numLst=[int(x) for x in str(number)]
    for i in range(len(numLst)-1):
        if not abs(numLst[i]-numLst[i+1])==1:
            return "Not!!"
    return "Jumping!!"

def jumping_number(number):
    s = str(number)
    print(s)
    for n,i in enumerate(s[1:]):
        l = int(s[n])
        i = int(i)
        if abs(l-i)!=1:
            return "Not!!"
        else:
            continue

    return "Jumping!!"       


def jumping_number(number):
    s = str(number)
    return "Jumping!!" if all(abs(int(s[i]) - int(s[i - 1])) == 1 for i in range(1, len(s))) else "Not!!"


def jumping_number(number):
    prev = number % 10
    number //= 10
    
    while number:
        digit = number % 10
        if abs(prev - digit) != 1:
            return 'Not!!'
        prev = digit
        number //= 10
        
    return 'Jumping!!'

def jumping_number(n):
    a = str(n)
    return "Jumping!!" if len([1 for x in range(len(a)-1) if int(a[x+1]) not in (int(a[x])+1, int(a[x])-1)]) == 0 else "Not!!"


def jumping_number(number):
    j=int(str(number)[0])
    for i in str(number)[1:]:
        if int(i)-j in (1,-1):
            j=int(i)
        else:
            return 'Not!!'
    return 'Jumping!!'

def jumping_number(number):
    number = str(number)
    jumping = True
    for i in range(1,len(number)): 
        if int(number[i])-int(number[i-1]) in [-1,1]:
            continue
        else:
            jumping = False
    return "Jumping!!" if jumping else "Not!!"

def jumping_number(number):
    n=str(number)
    if len(n)==1:
        return 'Jumping!!'
    else:
        for i in range(1,len(n)):
            if abs(int(n[i])-int(n[i-1]))==1:
                continue
            else:
                return 'Not!!'
        return "Jumping!!"

def jumping_number(number):
    w = str(number)
    for i in range(len(w) - 1) : 
        if abs(int(w[i]) - int(w[i + 1])) != 1 :
               return 'Not!!'
    return 'Jumping!!'           
               


def jumping_number(n):
    if n < 0:return "Not!!"
    s= str(n)
    if (len(s) == 1) :return "Jumping!!"    
    for i in range(1,len(s)):
        if abs(int(s[i])-int(s[i-1])) != 1:
            return "Not!!"
    else:
        return "Jumping!!"

def jumping_number(number):
    num_list = [int(i) for i in str(number)]
    jumping = 'Jumping!!'
    for i in range(len(num_list)):
        if i < len(num_list) - 1 and abs(num_list[i]-num_list[i+1]) != 1:
            jumping = 'Not!!'
    return jumping

def jumping_number(number):
    s = str(number)
    if len(s) < 2: return "Jumping!!"
    for i in range(1, len(s)):
        if abs(int(s[i]) - int(s[i-1])) != 1: return "Not!!"
    return "Jumping!!"

def jumping_number(number):
    number = str(number)
    for i in range(len(number)-1):
        if abs(int(number[i+1])-int(number[i])) != 1:
            return "Not!!"
    return "Jumping!!"

def jumping_number(number):
    if number < 11: 
        return "Jumping!!" 
    else:
        prev = int(str(number)[0])
        for i,x in enumerate(str(number)[1:]):
            if prev - int(x) == 1 or prev - int(x) == -1:
                prev = int(x)
            else:
                return "Not!!"
        return "Jumping!!" 

def jumping_number(number):
    n=str(number)
    if len(n)==1: return 'Jumping!!'
    else:
        x=0
        
        for x in range(0,len(n)-1):
            if abs(int(n[x])-int(n[x+1]))!=1:return 'Not!!'
            x+=1
    return 'Jumping!!'

def jumping_number(number):
    n=str(number)
    c=0
    if len(n)==1:
       return 'Jumping!!'
    for i in range(len(n)-1):
        if (int(n[i+1])==int(n[i])+1 or int(n[i+1])==int(n[i])-1):
            c+=1
    if c==len(n)-1:
       return 'Jumping!!'
    return 'Not!!'

def jumping_number(number):
    n = list(map(int, str(number)))
    if len(str(number)) == 1: return 'Jumping!!'
    else: return ["Not!!", "Jumping!!"][False not in [abs(a-b) == 1 for a, b in zip(n, n[1:])]]

def jumping_number(number):
    z = zip(map(int,str(number)[:-1]), map(int,str(number)[1:]))
    return ('Not','Jumping')[all([abs(a-b) == 1 for a,b in z]) or number < 10] + '!!'

def jumping_number(number):
    nstr = str(number)
    return 'Jumping!!' if all(abs(int(a) - int(b)) == 1 for a,b in zip(nstr, nstr[1:])) else 'Not!!'


def jumping_number(number):
    n = str(number)
    for i in range(len(n)-1) :
        if int(n[i])+1 != int(n[i+1]) and int(n[i])-1 != int(n[i+1]) : return "Not!!"
    return "Jumping!!"

def jumping_number(n):
    return 'Jumping!!' if all((int(a)-int(b))**2 == 1 for a,b in zip(str(n), str(n)[1:])) else 'Not!!'


def jumping_number(number):
    return 'Jumping!!' if number < 10 or (abs((number % 10) - (number // 10 % 10)) == 1 and jumping_number(number // 10) == 'Jumping!!') else 'Not!!'

def jumping_number(number):
    if len(str(number))==1:
        return "Jumping!!"
    else:
        res = list(map(int,str(number)))
        for i in range(len(res)-1):
            if abs(res[i+1]-res[i])!=1:
                return "Not!!"
                break
        return "Jumping!!"
                


def jumping_number(number):
    if number<10:
        return "Jumping!!"

    number=str(number)
    lnm=[]
    for i in number:
        lnm.append(i)
    for i in range(len(lnm)-1):
        if abs(int(lnm[i])-int(lnm[i+1]))!=1:
            return "Not!!"
    else:
        return "Jumping!!"

def jumping_number(number):
    if len(str(number)) == 1:
        return "Jumping!!"
    for i in range(0,len(str(number))-1):
        if abs(int(str(number)[i]) - int(str(number)[i+1])) != 1:
            return "Not!!"
    return "Jumping!!"

def jumping_number(number):
    
    s = str(number)
    l = len(s)
    
    return "Jumping!!" if sum([1 for x in range(1,l) if abs(int(s[x-1]) - int(s[x])) == 1]) == l - 1 else "Not!!"

def jumping_number(n):
    n=str(n)
    if len(n)==1: return "Jumping!!"
    return "Jumping!!" if all(abs(int(x)-int(y))==1 for x,y in zip(n[0:-1], n[1:])) else 'Not!!'

def jumping_number(number: int) -> str:
    digits = list(map(int, str(number)))
    return "Jumping!!" if all(abs(j - i) == 1 for i, j in zip(digits, digits[1:])) else "Not!!"


def jumping_number(number):
    s = int(str(number)[0]) - 1
    if len(str(number)) > 1:
        for i in str(number):
            if s + 1 == int(i) or s - 1 == int(i):
                s = int(i)
                continue
            else:
                return "Not!!"

    return "Jumping!!"

def jumping_number(number):
    number = str(number)
    if len(number)==1:
        return "Jumping!!"
    for i in range(1,len(number)):
        if abs(int(number[i])-int(number[i-1])) != 1:
            return "Not!!"
    return "Jumping!!"



def jumping_number(number):
    digits = [int(i) for i in str(number)]
    if len(digits) == 1:
        return 'Jumping!!'
    else:
        deltas = (abs(x-y) for x, y in zip(digits, digits[1:]))
        return 'Jumping!!' if all(delta==1 for delta in deltas) else 'Not!!'
        
        


def jumping_number(n):
    if n < 10: return 'Jumping!!'
    n = str(n)
    return 'Jumping!!' if all( abs(int(n[i])-int(n[i+1]) )==1 for i in range(len(n) - 1) ) else 'Not!!'

def jumping_number(number):
    string= str(number)
    for i in range(len(string)-1):
        if abs(int(string[i]) - int(string[i+1])) != 1: return "Not!!"
    return "Jumping!!"        


def jumping_number(n):
    n = list(str(n))
    for i in range(len(n)-1):
        if len(n) == 1:
            return "Jumping!!"
        elif abs(int(n[i]) - int(n[i+1])) != 1:
            return "Not!!"
            
    return "Jumping!!"
        
        


def jumping_number(number):
    a12 = list(map(int, str(number)))
    if len(a12)==1:
        return ("Jumping!!")
    else:
        for i in range(0,len(a12)-1):
            if ((a12[i]+1==a12[i+1]) or (a12[i]-1==a12[i+1])):
                continue
            else:
                return("Not!!")
        return("Jumping!!")

def jumping_number(number):
    number = str(number)
    return ("Jumping!!"if all(abs(int(number[i+1]) - int(number[i])) == 1 for i in range(len(number)-1)) else "Not!!")

def jumping_number(number):
    num = list(map(int, str(number)))
    if all(abs(x-y)==1 for x, y in zip(num, num[1:])): 
        return "Jumping!!"
    else: 
        return "Not!!"

def jumping_number(number):
    return "Jumping!!" if all(abs(int(str(number)[i]) - int(str(number)[i + 1])) == 1 for i in range(len(str(number)) - 1)) else "Not!!"

def jumping_number(n):
    lst = list(map(int, str(n)))
    return 'Jumping!!' if all(abs(x - y) == 1 for x, y in zip(lst, lst[1:])) else 'Not!!'

def jumping_number(number):
    numbers = [int(n) for n in str(number)]
    
    # assume input number is jumping until proven otherwise
    flag = True
    
    # this block will be skipped by single digit inputs
    while len(numbers) > 1:
        if abs(numbers[-1] - numbers[-2]) != 1:
            flag = False
            break
        numbers.pop(-1)
        
    return "Jumping!!" if flag else "Not!!"

def jumping_number(number):
    s = str(number)
    if len(s) == 1:
        return "Jumping!!"
    for i in range(len(s)-1):
        if(abs(int(s[i]) - int(s[i+1]))) != 1:
            return "Not!!"
            
    return "Jumping!!"

def jumping_number(number):
 curr=int(str(number)[0])
 number=str(number)[1:]
 for el in number:
  if int(el)-int(curr)!=1 and int(curr)-int(el)!=1:
   return "Not!!"
  curr=el
 return "Jumping!!"

def jumping_number(number):
    s=str(number)
    if len(s)==1:
        return "Jumping!!"
    else:
        for i in range(len(s)-1):
            if abs(int(s[i])-int(s[i+1]))!=1:
                   return "Not!!"
                   break  
        return "Jumping!!"    

def jumping_number(number):
    digits = list(map(int, f'{number}'))
    prev = digits.pop(0)
    while digits:
        curr = digits.pop(0)
        if curr != prev - 1 and curr != prev + 1:
            return 'Not!!'
        prev = curr
    return 'Jumping!!'

def jumping_number(number):
    if number<10:
        return "Jumping!!"
    else:
        digits=[]
        while number>0:
            digit=number%10
            number=number//10
            digits.append(digit)
        i=1
        jumping=True
        while i<len(digits):
            if abs(digits[i]-digits[i-1])!=1:
                jumping=False
                break
            i=i+1
        if jumping==True:
            return "Jumping!!"
        else:
            return "Not!!"

def jumping_number(number):
    nums = [int(i) for i in str(number)]
    n = len(nums)
    for i in range(n-1):
        if abs(nums[i] - nums[i+1]) != 1:
            return 'Not!!'
    return 'Jumping!!'

def jumping_number(number):
    arr = list(map(int, str(number)))
    return ['Not!!', 'Jumping!!'][all(map(lambda x, y: abs(x-y) == 1, arr, arr[1:]))]

def jumping_number(number):
    s = str(number)
    return 'Not!!' if any(abs(int(s[i-1]) - int(s[i])) != 1 for i in range(1, len(s))) else 'Jumping!!'

def jumping_number(n):
    n = str(n)
    return "Jumping!!" if all(abs(int(n[i+1]) - int(n[i])) == 1 for i in range(len(n)-1)) or int(n) < 9 else 'Not!!'

def jumping_number(number):
    number = str(number)
    for i in range(len(number)-1):
        if (int(number[i])-int(number[i+1]))**2 != 1:
            return 'Not!!'
    return 'Jumping!!'

def jumping_number(number):
    if len(str(number)) < 2:
        return 'Jumping!!'
    for i in range(len(str(number))-1):
        if abs(int(str(number)[i]) - int(str(number)[i+1])) != 1:
            return 'Not!!'
    return 'Jumping!!'

def jumping_number(number):
    n = str(number)
    value = 0
    for i in range(len(n)-1):
        if abs(int(n[i]) - int(n[i+1])) == 1:
            value +=1
    return "Jumping!!" if value == len(n) -1 else "Not!!"

def jumping_number(number):
    numbers = [int(n) for n in str(number)]
    i =0
    while i < len(numbers)-1:
        minus = numbers[i] - numbers[i+1]
        plus = numbers[i+1] - numbers[i]
        if minus != 1 and plus !=1 : 
            return "Not!!"
        i += 1
    return "Jumping!!"

def jumping_number(num):
    num = str(num)
    return ['Not!!',"Jumping!!"][all(abs(int(num[i+1]) - int(num[i])) == 1 for i in range(len(num)-1))]


def jumping_number(num):
    num = str(num)
    jumping = all(abs(int(a) - int(b)) == 1 for a, b in zip(num[:-1], num[1:]))
    return "Jumping!!" if jumping else "Not!!"

def jumping_number(number):
    t = str(number)
    i = 0
    if len(t) == 1:
        return "Jumping!!"
    
    while i < len(t)-1:
        if (int(t[i+1]) - int(t[i])) == 1 or (int(t[i+1]) - int(t[i])) == -1 :
            i = i + 1
        else: 
            return "Not!!"
    return "Jumping!!"

def jumping_number(n):
    s = str(n)
    l = []
    for i in range(len(s)):
        if i < len(s)-1:
            l.append(abs(int(s[i+1])-int(s[i])))
    return 'Jumping!!' if l == [] or n =='' or sum(l) == len(s)-1 else 'Not!!'


def jumping_number(number):
    print(number)
    if number < 10:
        return "Jumping!!"
    for k,v in enumerate(str(number)):
        if k == 0:
            if int(v) - int(str(number)[k+1]) in [1, -1]:
                pass
            else:
                return "Not!!"
        elif k == len(str(number)) - 1:
            if int(v) - int(str(number)[k-1]) in [1, -1]:
                pass
            else:
                return "Not!!"
        else:
            if int(v) - int(str(number)[k+1]) in [1, -1] and int(v) - int(str(number)[k+1]) in [1, -1]:
                pass
            else:
                return "Not!!"
    return "Jumping!!"


def jumping_number(number:int) -> str:
    num_str = str(number)
    for i,v in enumerate(num_str[:-1]):
        if abs(int(v) - int(num_str[i+1])) != 1:
            return "Not!!"
    else: # 'for-else' https://book.pythontips.com/en/latest/for_-_else.html#else-clause
        return "Jumping!!"