mjhjmtu

you could zip the string representation of the number with a shifted self and iterate on consecutive digits together. Use all to check that numbers follow, using a modulo 10 to handle the 0 case.

num = 7890

result = all((int(y)-int(x))%10 == 1 for x,y in zip(str(num),str(num)[1:]))

I would create a cycling generator and slice that:

from itertools import cycle, islice

num = 5678901234

num = tuple(str(num))
print(num == tuple(islice(cycle(map(str, range(10))), int(num[0]), int(num[0]) + len(num))))

This is faster than solutions that check differences between individual digits. Of course, you can sacrifice the length to make it faster:

def digits(num):
 while num:
 yield num % 10
 num //= 10

def check(num):
 num = list(digits(num))
 num.reverse()
 for i, j in zip(islice(cycle(range(10)), num[0], num[0] + len(num)), num):
 if i != j:
 return False
 return True

Since you already have the zip version, here is an alternative solution:

import sys


order = dict(enumerate(range(10)))
order[0] = 10

def increasing(n):
 n = abs(n)
 o = order[n % 10] + 1
 while n:
 n, r = divmod(n, 10)
 if o - order[r] != 1:
 return False
 o = order[r]
 return True


for n in sys.argv[1:]:
 print n, increasing(int(n))

Here's my take that just looks at the digits and exits as soon as there is a discrepancy:

def f(n):
 while (n):
 last = n % 10
 n = n / 10
 if n == 0:
 return True
 prev = n % 10
 print last, prev
 if prev == 0 or prev != (last - 1) % 10:
 return False

print f(1234)
print f(7890)
print f(78901)
print f(1345)

Somehow this question got me thinking of Palindromes and that got me to thinking of this in a different way.

5 6 7 8
8 7 6 5
-------------
13 13 13 13

9 0 1
1 0 9
---------
10 0 10


9 0 1 2
2 1 0 9
-------------
11 1 1 11

And that leads to this solution and tests.

pos_test_data = [5678, 901, 9012, 9012345678901]
neg_test_data = [5876, 910, 9021]

def monotonic_by_one(n):
 fwd = str(n)
 tgt = ord(fwd[0]) + ord(fwd[-1])
 return all([ord(f) + ord(r) in (tgt, tgt - 10) for f, r in zip(fwd, reversed(fwd))])


print("Positive: ", all([monotonic_by_one(n) for n in pos_test_data]))
print("Negative: ", all([not monotonic_by_one(n) for n in neg_test_data]))

Results:

Positive: True
Negative: True

Instead of using to full list comprehension you could use a for loop and bail out at the first failure. I'd want to look at the size of the numbers being checked and time somethings to decide which was faster.

I would try this, a little verbose for readability:

seq = list(input())
seq1 = seq[1:]
seq2 = seq[:-1]

diff = [x-y for x,y in zip([int(x) if int(x)>0 else 10 for x in seq1],[int(x) if int(x)>0 else 10 for x in seq2])]

if any (t != 1 for t in diff) :
 print('not <<<<<')
else :
 print('<<<<<<')