Question

所以我需要创建一个函数来找到可以除以2,3,4,5,6,7,8,9,10的最小自然数

这是我到目前为止所得到的：

def divisible():
    number= 2
    if number % 2 == 0:
        if number % 3 == 0:
            if number % 5 == 0:
                if number % 7 == 0:
                    if number % 9 == 0:
                        print number
    else:
        number = number + 2
divisible()

所以这就是我在那里所做的：

如果自然数可以完全除以2，那么它也可以除以4，而10和5则相同，因此我将它们删除了。然后我正在检查是否可以完全由所有其他数字完成除法。我的想法是打印可以通过所有这些条件的数字（如果是）。

另外，由于我正在寻找的数字可以除以2，这意味着它必须是偶数，所以我每次都加2。

我们的想法是找到一个可以完全由2,3,4,5,6,7,8,9和10分割的数字，然后打印出这个数字。

任何人都可以提供一些帮助吗？

Answer 1

您的代码没有循环数字; number保持静态，自number = 2以来，其他测试都失败了。那是因为你没有在这里制作循环。

您还从测试中删除了错误的数字;被2整除的数字不一定能被10整除，只有反之亦然。所以你需要在这里测试6,7,8,9和10。您可以使用if来测试一系列数字，而不是嵌套的all()语句集：

n = 0
while True:
    n += 10
    if all(n % i == 0 for i in (6, 7, 8, 9)):
        print(n)
        break

你需要至少增加10，一旦你以10为增量递增，测试是否可以被10整除是没有意义的。

这个生成第一个这样的数字。如果您需要测试，如果某个数字可以被所有这些因素整除，请使用%来测试这5个数字是否没有余数：

def is_divisible(n):
    return all(n % i == 0 for i in (6, 7, 8, 9, 10))

Answer 2

这个问题是计算最小公倍数（LCM）的问题。解决它的几种标准方法是使用最大公约数（GCD），素数因子分解和减少。

GCD开始发挥作用，对于两个整数a和b，

GCD(a,b)*LCM(a,b) = a*b

使用欧几里得算法计算GCD是众所周知的，尽管可能不是那个名字，但可以表示为

def gcd(x,y):
    while y:
        x,y = y,x%y
    return abs(x)

两个数字的GCD和LCM本身并不能解决两个以上的问题，但它们都具有相关性，这是一个减少超过两个数字的设置。这意味着：

GCD(a,b,c,d)=GCD(GCD(GCD(a,b),c),d)  # associativity
LCM(a,b,c,d)=LCM(LCM(LCM(a,b),c),d)  # associativity

和一些功能乐趣

reduce(fun,[a,b,c,d])

相当于

fun(fun(fun(a,b),c),d) # expanded reductive form

暗示

GCD(a,b,c,d) = reduce(GCD,[a,b,c,d])

LCM关联性还意味着仅需要两个参数LCM函数来减少超过两个，并且不需要GCD。这很好，因为它减少了开销，因为直接计算LCM所需的操作比使用GCD要少。

如果你想知道，GCD和LCM都是可交换的。这只是意味着参数列表中元素的顺序不会影响结果。

根据这些信息，回顾150多个LCM实现和一些测试，以下Python LCM功能在性能和简单性方面表现最佳：

def lcm(*args):
    def lcm2(x,y):
        tmp=x
        while (tmp%y)!=0:
            tmp+=x
       return tmp
    return reduce(lcm2,args)

此功能来自Eratosthenes对Least common multiple for 3 or more numbers的回答。

让我们看一下使用Python 3.4.3 x64

的表现

from functools import reduce

a = [2, 3, 4, 5, 6, 7, 8, 9, 10]

lcm(*a)
Out[9]: 2520

timeit lcm(*a)
100000 loops, best of 3: 5.95 µs per loop  

timeit lcm(2, 3, 4, 5, 6, 7, 8, 9, 10)
100000 loops, best of 3: 5.9 µs per loop

对于Python 2.7.10 x64

lcm(*a)
Out[60]: 2520

timeit lcm(*a)
100000 loops, best of 3: 4.36 µs per loop

timeit lcm(2, 3, 4, 5, 6, 7, 8, 9, 10)
100000 loops, best of 3: 4.33 µs per loop

LCM也可以使用素数因子分解来计算。算术的基本定理，也称为独特的因子定理，表示＆＃34;大于1的每个整数都是素数本身或者是素数的乘积，并且该乘积是唯一的，直到因子的数量级。＆＃34;这意味着除数列表中的每个除数具有素数因子分解，并且所有这些因子分解中的每个素数对于至少一个除数发生最大次数。因此，可以被所有除数（AKA）LCM均分的最小自然数是所有发生的素数的乘积，每个素数都被提升到其最大次数的幂。以下是此方法的实现代码：

from collections import defaultdict
from operator import mul
try:
    reduce
except:
    from functools import reduce

def findmnn(a):  

    def prime_factors(n):
        factors = defaultdict(int)
        d = 2
        step = 1
        while d*d <= n:
            while n>1:
                while n%d == 0:
                    factors[d] += 1
                    n = n/d
                d += step
                step = 2
        return factors

    d = defaultdict(int)

    for i in a:
        p = prime_factors(i)
        for j in p:
            if p[j] > d[j]:
                d[j] = p[j]

    return reduce(mul, map(lambda x: x**d[x], d))

给出除数列表

a = [2, 3, 4, 5, 6, 7, 8, 9, 10]

findmnn(a)
Out[3]: 2520

使用Python 2.7.10 x64使用timeit进行测试

timeit findmnn(a)
10000 loops, best of 3: 23.1 µs per loop

使用Python 3.4.3 x64在同一平台上使用timeit进行测试：

timeit findmnn(a)
10000 loops, best of 3: 49.4 µs per loop

进行比较并在同一平台上：

def mpmnn():
    n = 0
    while True:
        n += 10
        if all(n % i == 0 for i in (6, 7, 8, 9)):
            return n

使用Python 2.7.10 x64

timeit mpmnn()
1000 loops, best of 3: 245 µs per loop

使用Python 3.4.3 x64

timeit mpmnn()
1000 loops, best of 3: 244 µs per loop

以下是一些参考资料

Answer 3

这有效：

$http.get("data.json")

整除（）

在python

3 个答案: