Question

我正在研究一个问题，该问题确定数字中的数字是否按递增顺序排列。现在，我用来解决问题的方法是，例如考虑数字5678。

要检查5678是否为递增序列，我将第一个数字，下一个数字和最后一个数字分别为 5,6,8 并替换为范围函数 range（first ，last，（第一个数字与下一个数字的差）），即 range（5,8 + 1，abs（5-6））。结果是数字升序

对于这个问题，有一个约束条件

对于递增序列，0应该在9之后而不是1之前，就像在7890中一样。现在我的程序在输入7890处中断。我不知道如何对该逻辑进行编码。有人可以帮我吗？。

用于增加顺序的代码是

  len（set（[[5'，'6'，'7'，'8']）-set（map（str，range（5,8 + 1，abs（5-6））） ）））== 0

Answer 1

您只需检查数字转换为字符串后是否为CURLE_RECV_ERROR的子字符串：

'1234567890'

Answer 2

您可以将带有移位的self的数字的字符串表示形式压缩并在连续的数字上进行迭代。使用all来检查后面的数字，并使用模10来处理0情况。

num = 7890

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

Answer 3

由于您已经有了zip版本，因此这里是另一种解决方案：

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

Answer 4

我将创建一个循环生成器并对其进行切片：

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

这比检查单个数字之间的差异的解决方案要快。当然，您可以牺牲长度来加快速度：

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

Answer 5

这是我的看法，只是查看数字并在出现差异时退出：

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)

Answer 6

这个问题以某种方式使我想到了回文症，并以不同的方式想到了这个问题。

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

这导致了该解决方案和测试。

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]))

结果：

Positive:  True
Negative:  True

您可以使用for循环并在第一次失败时纾困，而不是使用完整列表理解。我想看看要检查的数字的大小，并花一些时间来确定哪个更快。

Answer 7

我会尝试这样做，为了提高可读性：

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

Answer 8

一种简单的解决方案，先检查序列中的下一个数字，然后使用current_number + 1 == next_number检测序列。

import bisect

def find_next(x, a):
  i = bisect.bisect_right(x, a)
  if i:
    return x[i]
  return None

def is_sequence(x):
  ans = True
  for i in x[:-1]:
    next_num = find_next(x, i)
    if next_num and i+1 != next_num:
      ans = False
      break
  return ans

print(is_sequence([1,2,3,4])) # True

检查数字中的数字是否在python中按升序排列

8 个答案: