Python 如果数字按降序排列，则返回true

对于下面的函数，如果数字按降序排列，我将尝试返回True；如果数字不按降序排列，则返回false

“数字”必须是正整数

这是我的代码：

def rev_num_sort(digits):
    n = len(digits)
    for i in range n:
        if digits[i] < digits[i+1]
            return False
    return True

我知道你不能计算int的长度，我在运行print语句时遇到了这个错误，但是我不知道如何在没有找到长度的情况下计算出来

>>> def rev_num_sort(num):
...     strs = str(num)
...     return strs == "".join(sorted(strs, reverse=True))
... 
>>> rev_num_sort(321)
True
>>> rev_num_sort(123)
False
>>> rev_num_sort(510)
True

使用

zip

和

any

，无需排序：

>>> def rev_num_sort(num):
...     strs = str(num)
...     return all(int(x) > int(y) for x, y in zip(strs, strs[1:]))
... 
>>> rev_num_sort(321)
True
>>> rev_num_sort(123)
False
>>> rev_num_sort(510)
True

使用

itertools.izip

和迭代器的高效内存版本：

>>> from itertools import izip
>>> def rev_num_sort(num):
...     strs = str(num)
...     it1 = iter(strs)
...     it2 = iter(strs)
...     next(it2)
...     return all(int(x) > int(y) for x, y in izip(it1, it2))
... 
>>> rev_num_sort(321)
True
>>> rev_num_sort(123)
False
>>> rev_num_sort(510)
True

使用

zip

和

any

，无需排序：

>>> def rev_num_sort(num):
...     strs = str(num)
...     return all(int(x) > int(y) for x, y in zip(strs, strs[1:]))
... 
>>> rev_num_sort(321)
True
>>> rev_num_sort(123)
False
>>> rev_num_sort(510)
True

使用

itertools.izip

和迭代器的高效内存版本：

>>> from itertools import izip
>>> def rev_num_sort(num):
...     strs = str(num)
...     it1 = iter(strs)
...     it2 = iter(strs)
...     next(it2)
...     return all(int(x) > int(y) for x, y in izip(it1, it2))
... 
>>> rev_num_sort(321)
True
>>> rev_num_sort(123)
False
>>> rev_num_sort(510)
True

---

我想整数运算，但我还没有测试效率

def isDigitsOrdered(digits) :
    base = 10
    lastNum = digits % base
    while True:
        base *= 10
        tmpNum = digits % base / (base / 10)
        if 0 == tmpNum and 0 == (digits/base):
            break
        if tmpNum >= lastNum :
            return False
        lastNum = tmpNum
    return True

最后，我自己用下面的例子来测试效率

#!/usr/bin/env python
import timeit

setup = """
def isDigitsOrdered(digits) :
    base = 10
    lastNum = digits % base
    while True:
        base *= 10
        tmpNum = digits % base / (base / 10)
        if 0 == tmpNum and 0 == (digits/base):
            break
        if tmpNum >= lastNum :
            return False
        lastNum = tmpNum
    return True

def rev_num_sort(digits):
    digits = str(digits)    # assuming digits is an int/long
    return all(digits[i-1] >= j for i, j in enumerate(digits) if i)

testdigits = (1234444444566788888999999999, 9999999998888876654444444321, 123456, 55667890)
gc.enable()
"""
testNum = 1000000
t1 = timeit.Timer("""
    for d in testdigits :
        isDigitsOrdered(d)
""",  setup)
print t1.timeit(testNum)

t2 = timeit.Timer("""
    for d in testdigits :
        rev_num_sort(d)
""",  setup)
print t2.timeit(testNum)

测试结果为：
16.6870310307
45.7681000233

---

这表明整数运算的时间开销比启用GC的字符串运算快得多。

我想要整数运算，但我还没有测试效率

def isDigitsOrdered(digits) :
    base = 10
    lastNum = digits % base
    while True:
        base *= 10
        tmpNum = digits % base / (base / 10)
        if 0 == tmpNum and 0 == (digits/base):
            break
        if tmpNum >= lastNum :
            return False
        lastNum = tmpNum
    return True

最后，我自己用下面的例子来测试效率

#!/usr/bin/env python
import timeit

setup = """
def isDigitsOrdered(digits) :
    base = 10
    lastNum = digits % base
    while True:
        base *= 10
        tmpNum = digits % base / (base / 10)
        if 0 == tmpNum and 0 == (digits/base):
            break
        if tmpNum >= lastNum :
            return False
        lastNum = tmpNum
    return True

def rev_num_sort(digits):
    digits = str(digits)    # assuming digits is an int/long
    return all(digits[i-1] >= j for i, j in enumerate(digits) if i)

testdigits = (1234444444566788888999999999, 9999999998888876654444444321, 123456, 55667890)
gc.enable()
"""
testNum = 1000000
t1 = timeit.Timer("""
    for d in testdigits :
        isDigitsOrdered(d)
""",  setup)
print t1.timeit(testNum)

t2 = timeit.Timer("""
    for d in testdigits :
        rev_num_sort(d)
""",  setup)
print t2.timeit(testNum)

测试结果为：
16.6870310307
45.7681000233

---

这表明整数运算的时间开销比启用GC的字符串运算快得多。

这是一个避免列表拷贝的短路版本

def rev_num_sort(digits):
    digits = str(digits)    # assuming digits is an int/long
    all(digits[i-1] >= j for i, j in enumerate(digits) if i)

---

这是一个避免列表副本的短路版本

def rev_num_sort(digits):
    digits = str(digits)    # assuming digits is an int/long
    all(digits[i-1] >= j for i, j in enumerate(digits) if i)

以下是gnibbler和mine（类似于Mr C）的一些性能比较，基于两者的timeit为10000倍（结果分别在元组中）：

降序

：

(0.48712682723999023, 0.8589978218078613)

gnibbler

：

(0.1695241928100586, 0.69327712059021)

我发现这相当令人惊讶，字符串方法要快得多

以下是gnibbler和mine（类似于Mr C）的一些性能比较，基于两者的timeit为10000倍（结果分别在元组中）：

降序

：

(0.48712682723999023, 0.8589978218078613)

gnibbler

：

(0.1695241928100586, 0.69327712059021)

---

---

我发现这相当令人惊讶，字符串方法要快得多

是的，我也要提出建议。谢谢你真是一种享受@艾玛很高兴这对你有帮助，如果答案对你有用，你可以接受。是的，我也要提出建议。谢谢你真是太棒了@Emma很高兴这有帮助，如果答案对你有用，你可以接受。看起来你还没有决定

数字是int、str还是list。选择一种类型，并在任何地方都坚持使用它，看起来您还没有决定
digits
是int、str还是list。选择一种类型，并在任何地方都坚持使用整数运算，只有在可以避免转换为以10为基数的情况下，使用整数运算才更有效——这对于大长度的情况尤其糟糕。既然你在这里有效地转换为10进制，你不妨利用
str
@gnibler。我的测试显示了结果，如果我遗漏了什么，请帮我找出答案。看起来你是在检查严格的升序数字。然而，你是正确的-你确实会短路，所以在这种情况下它可以更快。我注意到您返回的
False
即使是相等的数字，因此运行到完成的唯一案例是
123456
。您应该更改代码以匹配基准的降序要求，或者单独运行不同的案例，以突出显示不同算法的更快/更慢的案例。@gnibbler如果您是对的，我将>=替换为>，结果达到78.009221077，甚至更慢。顺便说一句，单独的测试用例不会影响测试结果，甚至会变得更慢。只有在可以避免转换为基数10的情况下，使用整数运算才更有效——这对于大长度的测试尤其糟糕。既然你在这里有效地转换为10进制，你不妨利用
str
@gnibler。我的测试显示了结果，如果我遗漏了什么，请帮我找出答案。看起来你是在检查严格的升序数字。然而，你是正确的-你确实会短路，所以在这种情况下它可以更快。我注意到您返回的
False
即使是相等的数字，因此运行到完成的唯一案例是
123456
。您应该更改代码以匹配基准的降序要求，或者单独运行不同的案例，以突出显示不同算法的更快/更慢的案例。@gnibbler如果您是对的，我将>=替换为>，结果达到78.009221077，甚至更慢。顺便说一句，单独的测试用例不会影响测试结果，它甚至变得更慢。您的版本是浮点版本而不是整数版本，因此它表示浮点操作比字符串慢得多。您的版本是浮点版本而不是整数版本，因此它表示浮点操作比字符串慢得多。