有效地生成小于 N 的所有合数（及其分解）

Question

我想构建一个高效的 Python 迭代器/生成器，它产生：

• 所有小于 N 的合数
• 连同它们的素数分解

我称之为“composites_with_factors()”

假设我们已经有一个小于 N 的素数列表，或者一个可以做同样事情的素数生成器。

注意我：

• 不需要按数字顺序生成数字
• 不关心是否在开头产生了 1
• 也不关心是否产生了素数

我认为这可以通过一个聪明的递归生成器来完成......

因此，例如，对 composites_with_factors(16) 的调用可能会产生：

# yields values in form of "composite_value, (factor_tuple)"
2, (2)
4, (2, 2)
8, (2, 2, 2)
6, (2, 3)
12, (2, 2, 3)
10, (2, 5)
14, (2, 7)
3, (3)
9, (3, 3)
15, (3, 5)
5, (5)
7, (7)
11, (11)
13, (13)

正如您从我的输出顺序中看到的那样，我认为这是通过从可用素数生成器上的最小素数开始，并输出该素数的所有幂小于 N 的，然后再尝试通过该素数的幂素数，但在每个阶段看看我是否可以应用额外素数的幂（并且仍然小于 N）。当所有与那个素数的组合都完成后，放下它，然后用素数生成器上可用的下一个最低素数重复。

我尝试用“递归生成器”来做这件事让我很困惑，什么时候用“yield”、“raise StopIteration”或“return”退出递归，或者干脆退出递归函数.

感谢您的智慧！

补充说明：

我确实现在有一种方法可以做到这一点：我编写了一个分解数字的函数，因此我可以将它们分解为素数，并产生结果。没问题。我依靠“数字 N 的最低素数是多少”的缓存来保持这一速度极快......对于 N 高达 1000 万。

但是，一旦我从缓存中取出，我们就会将其转移到“幼稚”的因式分解。 （呸。）

这篇文章的重点是：

• 我假设“从它们的因子生成大型复合材料”将比“分解大型复合材料”更快...尤其是因为我不关心顺序，并且
• 如何让 Python 生成器“递归”调用自身，并生成一个生成的东西流？

Answer 1

这是一个基于筛子的实现（请原谅非pythonic代码:)）：

def sieve(n):
    # start each number off with an empty list of factors
    #   note that nums[n] will give the factors of n
    nums = [[] for x in range(n)]
    # start the counter at the first prime
    prime = 2
    while prime < n:
        power = prime
        while power < n:
            multiple = power
            while multiple < n:
                nums[multiple].append(prime)
                multiple += power
            power *= prime
        # find the next prime
        #   the next number with no factors
        k = prime + 1
        if k >= n:    # no primes left!!!
            return nums
        # the prime will have an empty list of factors
        while len(nums[k]) > 0:
            k += 1
            if k >= n:    # no primes left!!!
                return nums
        prime = k
    return nums


def runTests():
    primes = sieve(100)
    if primes[3] == [3]:
        print "passed"
    else:
        print "failed"
    if primes[10] == [2,5]:
        print "passed"
    else:
        print "failed"
    if primes[32] == [2,2,2,2,2]:
        print "passed"
    else:
        print "failed"

测试：

>>> runTests()
passed
passed
passed

在我的机器上，这需要 56 秒才能运行：

primes = sieve(14000000) # 14 million!

例子：

>>> primes[:10]
[[], [], [2], [3], [2, 2], [5], [2, 3], [7], [2, 2, 2], [3, 3]]

>>> primes[10000]
[2, 2, 2, 2, 5, 5, 5, 5]

>>> primes[65536]
[2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]

>>> primes[6561]
[3, 3, 3, 3, 3, 3, 3, 3]

>>> primes[233223]
[3, 17, 17, 269]

内存消耗：大约 5000 万个整数，在 1400 万个列表中：

>>> sum(map(len, primes))
53303934

Answer 2

递归（伪代码）：

def get_factorizations_of_all_numbers( start = starting_point
                                     , end = end_point
                                     , minp = mimimum_prime
                                     ):
    if start > end:
        return Empty_List
    if minp ^ 2 > end:
        return list_of_all_primes( start, end )
    else
        a = minp * get_factorizations_of_all_numbers( rounddown(start/minp)
                                                    , roundup(end/minp)
                                                    )
        b = get_factorizations_of_all_numbers( start
                                             , end
                                             , next_prime( minp )
                                             )
        return append( a , b )

get_factorizations_of_all_numbers( 1, n, 2 )

Answer 3

假设primesiter(n) 会在直到n 的所有素数上创建一个迭代器（primesiter 中不应包含 1，否则以下代码将进入 inf.循环）

def composite_value(n, min_p = 0):
    for p in primesiter(n):
        # avoid double solutions such as (6, [2,3]), and (6, [3,2])
        if p < min_p: continue
        yield (p, [p])
        for t, r in composite_value(n//p, min_p = p): # uses integer division
            yield (t*p, [p] + r)

输出

>> list(composite_value(16))
[(2, [2]),
 (4, [2, 2]),
 (8, [2, 2, 2]),
 (16, [2, 2, 2, 2]),
 (12, [2, 2, 3]),
 (6, [2, 3]),
 (10, [2, 5]),
 (14, [2, 7]),
 (3, [3]),
 (9, [3, 3]),
 (15, [3, 5]),
 (5, [5]),
 (7, [7]),
 (11, [11]),
 (13, [13])]

注意：它也包括 n (= 16)，我使用列表而不是元组。如果需要，两者都可以轻松解决，但我将把它留作练习。