# 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

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Mathematics

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!!')


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)) == 1 for (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):
	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(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):
	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):
	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):
	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):
	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):
	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(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):
	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)
	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):
	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):
	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):
	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):
	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(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)]
	flag = True
	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):
	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):
	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):
	arr = list(map(int, str(number)))
	return ['Not!!', 'Jumping!!'][all(map(lambda x, y: abs(x - y) == 1, arr, arr[1:]))]


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):
	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(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!!'
		elif 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:
		return 'Jumping!!'