Ngtjyty

I was working on a problem that determines whether the digits in the numbers are in the increasing sequence. Now, the approach I took to solve the problem was, For instance, consider the number 5678.

To check whether 5678 is an increasing sequence, I took the first digit and the next digit and the last digit which is 5,6,8 and substitute in range function range(first,last,(diff of first digit and the next to first digit)) i.e range(5,8+1,abs(5-6)).The result is the list of digits in the ascending order

To this problem, there is a constraint saying

For incrementing sequences, 0 should come after 9, and not before 1, as in 7890. Now my program breaks at the input 7890. I don't know how to encode this logic. Can someone help me, please?.

The code for increasing sequence was

  len(set(['5','6','7','8']) - set(map(str,range(5,8+1,abs(5-6))))) == 0 

You can simply check if the number, when converted to a string, is a substring of '1234567890':

str(num) in '1234567890'

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:

        r = n % 10

        n = 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 != (10 + last - 1) % 10:

      return False



print f(1234)

print f(7890)

print f(78901)

print f(1345)