如何缩短和提高这个 Python 代码块的效率

Question

如何缩短和提高这个 Python 代码块的效率

31

我是编程和Python的完全新手。我正在解决一个问题。我找到了解决方案，但似乎太慢了。

    if n % 2 == 0 and n % 3 == 0 and\
       n % 4 == 0 and n % 5 == 0 and\
       n % 6 == 0 and n % 7 == 0 and\
       n % 8 == 0 and n % 9 == 0 and\
       n % 10 == 0 and n % 11 == 0 and\
       n % 12 == 0 and n % 13 == 0 and\
       n % 14 == 0 and n % 15 == 0 and\
       n % 16 == 0 and n % 17 == 0 and\
       n % 18 == 0 and n % 19 == 0 and\
       n % 20 == 0:

这段代码用来检查数字n是否能被2到20之间所有的数整除。

我该如何让它更短更高效？

- Sanatan Chaudhary

5

你知道for循环吗？ - pistache

29

请勿使用反斜杠继续这些行。它们非常容易断开（只需在反斜杠后添加一个空格即可获得“SyntaxError”）。取而代之的是：将条件括在括号内：“if (n％2 == 0 and n％3 == 0 <newline> and n％4 == 0 and n％5 == 0 <newline> and n％6 == 0 ...)：”行的延续是隐式的。 - Bakuriu

2

我找不到完全相同的副本，但这里有一些相关的问题https://dev59.com/0pnga4cB1Zd3GeqPZHmn#38720186和https://dev59.com/SXVC5IYBdhLWcg3wykej - Mazdak

8

你知道吗，你不需要检查所有的情况。如果 n % 20 == 0 为真，则 n % 2 == 0、n % 5 == 0 和 n % 10 == 0 必须也为真。或许考虑一下这个，看看你能省略多少次检查。 - Blorgbeard

1

@AlexanderMomchliov，实际上不仅仅是质数，因为它们不能解释平方数的倍数，比如4。在这种情况下，您实际上只需要检查最高必要的平方数：16、9、5、7、11、13、17和19。 - Solomon Ucko

显示剩余10条评论

11个回答

59

有一种更聪明的方法来做这件事。如果n可以被1到21范围内的每个整数整除，那么它必须是这些整数的最小公倍数的倍数。

您可以使用GCD（最大公约数）逐步计算一组数字的LCM。您可以从fractions模块导入gcd函数，或直接在代码中实现它。

def gcd(a, b):
    ''' Greatest Common Divisor '''
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    ''' Least Common Multiple '''
    return a * b // gcd(a, b)

# Compute the LCM of range(1, 21)
n = 2
for i in range(3, 21):
    n = lcm(n, i)

lcm20 = n
print('LCM =', lcm20)
#test 
for i in range(1, 21):
    print(i, lcm20 % i)

输出

LCM = 232792560
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
10 0
11 0
12 0
13 0
14 0
15 0
16 0
17 0
18 0
19 0
20 0

现在，如果要测试任何一个数字n是否可以被1到21范围内的所有数字整除，您只需执行以下操作：

n % lcm20 == 0

或者在您的脚本中硬编码该常量：

# 232792560 is the LCM of 1..20
n % 232792560 == 0

如Anton Sherwood在他的评论中所指出的，我们可以通过仅取范围上半部分的LCM来加速查找所需LCM的过程。这是可行的，因为范围下半部分的每个数字都是范围上半部分某个数字的约数。

我们可以通过内联GCD和LCM计算来进一步提高速度，而不是调用函数执行这些操作。由于涉及额外开销，Python函数调用比C函数调用慢得多。

Yakk提到了另一种寻找所需LCM的方法：计算范围内素数幂的乘积。如果范围足够大（大约40左右），这很快，但对于小数值，简单的LCM循环更快。

下面是一些比较各种方法速度的 timeit 代码。此脚本在 Python 2 和 3 上运行，我已在 Python 2.6 和 Python 3.6 上进行了测试。它使用 Robert William Hanks 的质数列表函数来实现 Yakk 的建议。我稍微修改了 Robert 的代码，以使其与 Python 3 兼容。我想可能有更有效的方法来查找质数幂；如果有的话，我想看看。:)

我之前提到过，在 fractions 模块中有一个 GCD 函数。我对它进行了一些时间测试，但它明显比我的代码慢。这可能是因为它在参数上进行错误检查。

#!/usr/bin/env python3

''' Least Common Multiple of the numbers in range(1, m)

    Speed tests

    Written by PM 2Ring 2016.08.04
'''


from __future__ import print_function
from timeit import Timer
#from fractions import gcd

def gcd(a, b):
    ''' Greatest Common Divisor '''
    while b:
        a, b = b, a % b
    return a

def lcm(a, b):
    ''' Least Common Multiple '''
    return a * b // gcd(a, b)

def primes(n):
    ''' Returns a list of primes < n '''
    # By Robert William Hanks, from https://dev59.com/snI95IYBdhLWcg3w-DH0#3035188
    sieve = [True] * (n//2)
    for i in range(3, int(n ** 0.5) + 1, 2):
        if sieve[i//2]:
            sieve[i*i//2::i] = [False] * ((n - i*i - 1) // (2*i) + 1)
    return [2] + [2*i + 1 for i in range(1, n//2) if sieve[i]]

def lcm_range_PM(m):
    ''' The LCM of range(1, m) '''
    n = 1
    for i in range(2, m):
        n = lcm(n, i)
    return n

def lcm_range_AS(m):
    ''' The LCM of range(1, m) '''
    n = m // 2
    for i in range(n + 1, m):
        n = lcm(n, i)
    return n

def lcm_range_fast(m):
    ''' The LCM of range(1, m) '''
    n = m // 2
    for i in range(n + 1, m):
        a, b = n, i
        while b:
            a, b = b, a % b
        n = n * i // a
    return n

def lcm_range_primes(m):
    n = 1
    for p in primes(m):
        a = p
        while a < m:
            a *= p
        n *= a // p
    return n

funcs = (
    lcm_range_PM,
    lcm_range_AS,
    lcm_range_fast,
    lcm_range_primes
)

def verify(hi):
    ''' Verify that all the functions give the same result '''
    for i in range(2, hi + 1):
        a = [func(i) for func in funcs]
        a0 = a[0]
        assert all(u == a0 for u in a[1:]), (i, a)
    print('ok')

def time_test(loops, reps):
    ''' Print timing stats for all the functions '''
    timings = []
    for func in funcs:
        fname = func.__name__
        setup = 'from __main__ import num, ' + fname
        cmd = fname + '(num)'
        t = Timer(cmd, setup)
        result = t.repeat(reps, loops)
        result.sort()
        timings.append((result, fname))

    timings.sort()
    for result, fname in timings:
        print('{0:16} {1}'.format(fname, result))

verify(500)

reps = 3
loops = 8192
num = 2
for _ in range(10): 
    print('\nnum = {0}, loops = {1}'.format(num, loops))
    time_test(loops, reps)
    num *= 2
    loops //= 2

print('\n' + '- ' * 40)

funcs = (
    lcm_range_fast,
    lcm_range_primes
)

loops = 1000
for num in range(30, 60):
    print('\nnum = {0}, loops = {1}'.format(num, loops))
    time_test(loops, reps)

输出

ok

num = 2, loops = 8192
lcm_range_PM     [0.013914467999711633, 0.01393848999941838, 0.023966414999449626]
lcm_range_fast   [0.01656803699916054, 0.016577592001340236, 0.016578077998929075]
lcm_range_AS     [0.01738608899904648, 0.017602848000024096, 0.01770572900022671]
lcm_range_primes [0.0979132459997345, 0.09863009199943917, 0.10133290699923236]

num = 4, loops = 4096
lcm_range_fast   [0.01580070299860381, 0.01581421999981103, 0.016406731001552544]
lcm_range_AS     [0.020135083001150633, 0.021132826999746612, 0.021589830999801052]
lcm_range_PM     [0.02821666900126729, 0.029041511999821523, 0.036708851001094445]
lcm_range_primes [0.06287289499960025, 0.06381634699937422, 0.06406087200048205]

num = 8, loops = 2048
lcm_range_fast   [0.015360695999333984, 0.02138442599971313, 0.02630166100061615]
lcm_range_AS     [0.02104746699842508, 0.021742354998423252, 0.022648989999652258]
lcm_range_PM     [0.03499621999981173, 0.03546843599906424, 0.042924503999529406]
lcm_range_primes [0.03741390599861916, 0.03865244000007806, 0.03959638999913295]

num = 16, loops = 1024
lcm_range_fast   [0.015973221999956877, 0.01600381199932599, 0.01603960700049356]
lcm_range_AS     [0.023003745000096387, 0.023848425998949097, 0.024875303000953863]
lcm_range_primes [0.028887982000014745, 0.029422679001072538, 0.029940758000520873]
lcm_range_PM     [0.03780223299872887, 0.03925949299991771, 0.04462484900068375]

num = 32, loops = 512
lcm_range_fast   [0.018606906000059098, 0.02557359899947187, 0.03725786200084258]
lcm_range_primes [0.021675119000065024, 0.022790905999499955, 0.03934840099827852]
lcm_range_AS     [0.025330593998660333, 0.02545427500081132, 0.026093265998497372]
lcm_range_PM     [0.044320442000753246, 0.044836185001258855, 0.05193238799984101]

num = 64, loops = 256
lcm_range_primes [0.01650579099987226, 0.02443148000020301, 0.033489004999864846]
lcm_range_fast   [0.018367127000601613, 0.019002625000211992, 0.01955779200034158]
lcm_range_AS     [0.026258470001266687, 0.04113643799973943, 0.0436801750001905]
lcm_range_PM     [0.04854909000096086, 0.054864030998942326, 0.0797669980001956]

num = 128, loops = 128
lcm_range_primes [0.013294352000229992, 0.013383581999732996, 0.024317635999977938]
lcm_range_fast   [0.02098568399924261, 0.02108044199849246, 0.03272008299973095]
lcm_range_AS     [0.028861763999884715, 0.0399744570004259, 0.04660961700028565]
lcm_range_PM     [0.05302166500041494, 0.059346372001527925, 0.07757829000001948]

num = 256, loops = 64
lcm_range_primes [0.010487794999789912, 0.010514846000660327, 0.01055656300013652]
lcm_range_fast   [0.02619308099929185, 0.02637610199963092, 0.03755473099954543]
lcm_range_AS     [0.03422451699952944, 0.03513622399987071, 0.05206341099983547]
lcm_range_PM     [0.06851765200008231, 0.073690847000762, 0.07841700100107118]

num = 512, loops = 32
lcm_range_primes [0.009275872000216623, 0.009292663999076467, 0.009309271999882185]
lcm_range_fast   [0.03759837500001595, 0.03774761099884927, 0.0383951439998782]
lcm_range_AS     [0.04527828100071929, 0.046646228000099654, 0.0569303670017689]
lcm_range_PM     [0.11064135100059502, 0.12738902800083451, 0.13843623499997193]

num = 1024, loops = 16
lcm_range_primes [0.009248070000467123, 0.00931658900117327, 0.010279963000357384]
lcm_range_fast   [0.05642254200029129, 0.05663530499987246, 0.05796714499956579]
lcm_range_AS     [0.06509247900066839, 0.0652738099997805, 0.0658949799999391]
lcm_range_PM     [0.11376448099872505, 0.11652833600055601, 0.12083648199950403]

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 

num = 30, loops = 1000
lcm_range_fast   [0.03275446999941778, 0.033530079999763984, 0.04002811799909978]
lcm_range_primes [0.04062690899991139, 0.040886697999667376, 0.04130547800014028]

num = 31, loops = 1000
lcm_range_fast   [0.03423191600086284, 0.039976395999474335, 0.04078094900069118]
lcm_range_primes [0.04053011599899037, 0.04140578700025799, 0.04566663300101936]

num = 32, loops = 1000
lcm_range_fast   [0.036124262000157614, 0.036700047998238006, 0.04392546200142533]
lcm_range_primes [0.042666604998885305, 0.04393434200028423, 0.05142524700022477]

num = 33, loops = 1000
lcm_range_fast   [0.03875456000059785, 0.03997290300139866, 0.044469664000644116]
lcm_range_primes [0.04280027899949346, 0.0437891679994209, 0.04381238600035431]

num = 34, loops = 1000
lcm_range_fast   [0.038203157999305404, 0.03937257799952931, 0.04531203700025799]
lcm_range_primes [0.043273317998682614, 0.043349457999283914, 0.04420187600044301]

num = 35, loops = 1000
lcm_range_fast   [0.04228670399970724, 0.04346491300020716, 0.047442203998798504]
lcm_range_primes [0.04332462999991549, 0.0433610400014004, 0.04525857199951133]

num = 36, loops = 1000
lcm_range_fast   [0.04175829099949624, 0.04217126499861479, 0.046840714998324984]
lcm_range_primes [0.04339772299863398, 0.04360795700085873, 0.04453475599984813]

num = 37, loops = 1000
lcm_range_fast   [0.04231068799890636, 0.04373836499871686, 0.05010528200000408]
lcm_range_primes [0.04371378700125206, 0.04463105400100176, 0.04481986299833807]

num = 38, loops = 1000
lcm_range_fast   [0.042841554000915494, 0.043649038998410106, 0.04868016199907288]
lcm_range_primes [0.04571479200058093, 0.04654245399979118, 0.04671720700025617]

num = 39, loops = 1000
lcm_range_fast   [0.04469198100014182, 0.04786454099848925, 0.05639159299971652]
lcm_range_primes [0.04572433999965142, 0.04583652600013011, 0.046649005000290344]

num = 40, loops = 1000
lcm_range_fast   [0.044788433999201516, 0.046223339000789565, 0.05302252199908253]
lcm_range_primes [0.045482261000870494, 0.04680115900009696, 0.046941823999077315]

num = 41, loops = 1000
lcm_range_fast   [0.04650144500010356, 0.04783133000091766, 0.05405569400136301]
lcm_range_primes [0.04678159699869866, 0.046870936999766855, 0.04726529199979268]

num = 42, loops = 1000
lcm_range_fast   [0.04772527699969942, 0.04824955299955036, 0.05483534199993301]
lcm_range_primes [0.0478546140002436, 0.048954233001495595, 0.04905354400034412]

num = 43, loops = 1000
lcm_range_primes [0.047872637000182294, 0.048093739000250935, 0.048502418998396024]
lcm_range_fast   [0.04906317900167778, 0.05292572700091114, 0.09274570399975346]

num = 44, loops = 1000
lcm_range_primes [0.049750300000596326, 0.050272532000235515, 0.05087747600009607]
lcm_range_fast   [0.050906279000628274, 0.05109869400075695, 0.05820328499976313]

num = 45, loops = 1000
lcm_range_primes [0.050158660000306554, 0.050309066000409075, 0.054478109999763547]
lcm_range_fast   [0.05236714599959669, 0.0539534259987704, 0.058996140000090236]

num = 46, loops = 1000
lcm_range_primes [0.049894845999006066, 0.0512076260001777, 0.051318084999365965]
lcm_range_fast   [0.05081920200063905, 0.051397655999608105, 0.05722950699964713]

num = 47, loops = 1000
lcm_range_primes [0.04971165599999949, 0.05024208400027419, 0.051092388999677496]
lcm_range_fast   [0.05388393700013694, 0.05502788499870803, 0.05994341699988581]

num = 48, loops = 1000
lcm_range_primes [0.0517014939996443, 0.05279760400117084, 0.052917389999493025]
lcm_range_fast   [0.05402479099939228, 0.055251746000067214, 0.06128628700025729]

num = 49, loops = 1000
lcm_range_primes [0.05412415899991174, 0.05474224499994307, 0.05610057699959725]
lcm_range_fast   [0.05757830900074623, 0.0590323519991216, 0.06310263200066402]

num = 50, loops = 1000
lcm_range_primes [0.054892387001018506, 0.05504404100065585, 0.05610281799999939]
lcm_range_fast   [0.0588886920013465, 0.0594741389995761, 0.06682244199873821]

num = 51, loops = 1000
lcm_range_primes [0.05582956999933231, 0.055921465000210446, 0.06004790299994056]
lcm_range_fast   [0.060586288000195054, 0.061715600999377784, 0.06733965300009004]

num = 52, loops = 1000
lcm_range_primes [0.0557458109997242, 0.05669860099988, 0.056761407999147195]
lcm_range_fast   [0.060323355999571504, 0.06177857100010442, 0.06778404599936039]

num = 53, loops = 1000
lcm_range_primes [0.05501838899908762, 0.05541463699955784, 0.0561610999993718]
lcm_range_fast   [0.06281833000139159, 0.06334177999997337, 0.06843207200108736]

num = 54, loops = 1000
lcm_range_primes [0.057314272000439814, 0.059501444000488846, 0.060004871998899034]
lcm_range_fast   [0.06634221600143064, 0.06662889200015343, 0.07153233899953193]

num = 55, loops = 1000
lcm_range_primes [0.05790564500057371, 0.05824322199987364, 0.05863306900027965]
lcm_range_fast   [0.06693624800027465, 0.06784769100158883, 0.07562533499913116]

num = 56, loops = 1000
lcm_range_primes [0.057219010001063, 0.05858367799919506, 0.06246676000046136]
lcm_range_fast   [0.06854197999928147, 0.06999059400004626, 0.07505119899906276]

num = 57, loops = 1000
lcm_range_primes [0.05746709300001385, 0.0587476679993415, 0.0606189070003893]
lcm_range_fast   [0.07094627400147147, 0.07241532700027165, 0.07868066799892404]

num = 58, loops = 1000
lcm_range_primes [0.0576490580006066, 0.058481812999161775, 0.05857339500107628]
lcm_range_fast   [0.07127979200049595, 0.07549924399972952, 0.07849203499972646]

num = 59, loops = 1000
lcm_range_primes [0.057503377998727956, 0.058632499998566345, 0.060360438999850885]
lcm_range_fast   [0.07332589399993594, 0.07625177999943844, 0.08087236799838138]

这个时间信息是使用 Python 3.6 在一个基于 Debian 的 Linux 系统上生成的，运行在一台古老的 2GHz Pentium IV 机器上。

- PM 2Ring

2

计算2到20之间所有数字的最小公倍数的一种较少代码密集的方法是找到该范围内每个质数的最大幂。因此，5,7,9,11,13,16,17,19的乘积为232792560。这样独立的方法可以确认您的算法没有错误。 - Yakk - Adam Nevraumont

@Yakk 啊，好的。顺便说一句，我确实考虑过在范围内获取每个数字的质因数，并使用max获取所需的最高质数幂，但我认为这比我的GCD循环获得LCD更加密集。但是在看到您的评论之前，我没有想过使用修改后的筛法更有效地获得质数幂。 :) - PM 2Ring

@Yakk 我已经实现了你的建议，但是对于小范围来说，它变得更慢了。但是对于大范围来说，它比简单的LCM循环更快。 :) 如果你知道一种更有效的方法（不涉及使用C语言编写的第三方库）来计算范围内的质数幂，请告诉我。 - PM 2Ring

@pm2ring memoize！如果计算只在小范围内完成，那么速度慢也无所谓。但对于大范围或重复计算，最好使用更快和/或缓存的方法。 - Yakk - Adam Nevraumont

@Yakk 当然，如果我要计算很多这样的lcm_ranges，那么我会预先构建一个足够大的质数表，如果我有最大范围大小的大致想法，或者使用可扩展筛子（sieve）如果那不是实际的。如果我知道我可能需要相同的lcm_range超过一次，我肯定会将其记忆化（可能使用可变默认参数作为缓存，因为这比使用@decorator明显更快）。 - PM 2Ring

49

if all(n % i == 0 for i in range(2, 21)):

all 接受一个可迭代对象，如果其中所有元素都为 True，则返回 True，否则返回 False。 n % i == 0 for i in range(2, 21) 部分会返回一个可迭代对象，包含19个 True 或 False 值，这取决于 n 是否能被相应的 i 值整除。

- DeepSpace

7

内置的all函数会有所帮助。

如果可迭代对象中的所有元素都为True（或者可迭代对象为空），则返回True。

if all(n % i == 0 for i in xrange(2, 21))

- Vishnu Upadhyay

你需要对这个结果取反，即not all(n % i for i in range(2, 21))。 - Mazdak

@Kasramvd 感谢您的建议，我会相应地更新我的答案。 - Vishnu Upadhyay

@Kasramvd，你的表达意思是“如果n是范围内某个数字的倍数”，但OP想要“如果n是范围内每个数字的倍数”——这相当于not any(n%i for i in range(11, 21))。 - Anton Sherwood

4

这只是一种数学技巧，使用类似于n % "LCM(1,2,...,20) == 0的方法，可以编写如下代码：

if n % 232792560 == 0:
    #do whatever you want

- Masked Man

我同意使用LCM是正确的方法，但720720不是LCM(1,2,...,20)。请查看我的答案和http://oeis.org/A003418。 - PM 2Ring

语法错误：扫描字符串文字时遇到行尾 (EOL) - Marc van Leeuwen

@MarcvanLeeuwen，抱歉我不明白你说的话。 - Masked Man

1

@MaskedMan，你的第一个表达式以n％“LCM开头，但没有尾随的"。@MarcvanLeeuwen给出了Python编译器将为此生成的输出。 - Martin Bonner supports Monica

1

Python代码有时看起来很像伪代码;-) - gerrit

显示剩余4条评论

4

为了多样性，您可以使用循环完成此操作的方式如下：

test = True
for modulus in range(2, 21):
    if n % modulus != 0:
        test = False
        break
if test:
    # Do stuff

如果您对于 for-else 感到熟悉，您可以通过以下方式提高简洁性。

for modulus in range(2, 21):
    if n % modulus != 0:
        break
else:
    # Do stuff

尽管这种模式可能足够不寻常，以至于您不想使用它。另一个选项是编写一个帮助函数。

def is_divisible_by_integers_up_to(n, bound):
    for modulus in range(2, bound + 1):
        if n % modulus != 0:
            return False
    return True

if is_divisible_by_integers_up_to(n, 20):
    # Do stuff

然而，这个例子足够简单，可以按照其他答案中描述的使用生成器表达式进行 all 操作，这是最好的方法。

- user1084944

3

你需要一个条件，当所有的除法余数都为零时，它才能评估为True。到目前为止提出的两个解决方案似乎没有做到这一点。我怀疑你需要的条件是：

if not any(n % i for i in range(2, 21)):

- holdenweb

3

许多上述代码示例虽然较短，但（可能）不够高效：

n%2 == 0 =>
    n%4 6 8... ==0
n%3 == 0 =>
    n%3 6 9... ==0

我们可以只使用质数来检查范围内的数：

if all(n % i == 0 for i in [2,3,5,7,11,13,17,19])

此外，如果n能被2到20中的所有数整除，则它也能整除2到20的最小公倍数。

- zinking

这会给出错误的答案，因为这些质数的乘积既不可被4整除也不可被9整除。 - Anton Sherwood

@AntonSherwood 感谢您指出。显然您是正确的，这不是质数的最小公倍数，而是所有数的最小公倍数。 - zinking

遗憾的是，这并不正确。但你已经走在了正确的路上：请参考 @Yakk 在本页面其他地方的评论。 - Bathsheba

2

我自己是一个非常轻量级的Python用户，并且我不知道所有这些解决方案。这些解决方案非常酷（可能比我即将发布的更有效），但是如果您想看到另一种方法，这里有另一个选择：

def IsDivUpTo20(n):
   for i in range(2, 21):
      if n % i != 0:
         return False
   return True

然后这样调用

if IsDivUpTo20(50):
   #what to do if it is divisible
else:
   #what to do if it isn't
#for the example of 50, it'll be false and jump to the else part, but you can put any number of variable in there

功能上，它的运作方式与“全部”(all)基本相同，但如果你不熟悉花式语法和内置函数，这个会更加直观。

*注意：我使用的是Python 3，而不是标记为Python 2.7的版本。我很确定这在那个版本中也可以工作，但如果不行，请有人纠正我。

- Cody

2

与之前的回答类似：

import operator
x = 232792560
if reduce(operator.__and__, [x % n == 0 for n in xrange(2, 21, 2)]):
    print("ok")

- copper.hat

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Bathsheba · Accepted Answer

短小精悍和高效之间存在权衡。

短小精悍的写法是if all(n % i == 0 for i in range(2, 21)):

高效的写法是注意到像n % 20 == 0这样的东西也意味着n % f == 0，其中f是20的任何因子。例如，可以省略n % 2 == 0。因此，你会少一些比较，代码运行得更快。在这个过程中，你会发现一个模式，并且你会发现整个语句简化为if n % 232792560 == 0！但这现在已经深深地嵌入到20中，如果需要一个不同的上限，就很难分解了。

所以你看，高效的方式并不容易阅读和维护。因此，请根据你的需求选择最合适的方式。