Python 返回一个数组，该数组包含乘积为x的素数_Python_Algorithm_List_Primes

Python 返回一个数组，该数组包含乘积为x的素数

python algorithm list

Python 返回一个数组，该数组包含乘积为x的素数,python,algorithm,list,primes,Python,Algorithm,List,Primes,我迷路了。我的函数在某些情况下有效，但在某些情况下不起作用。例如，提供数字110019时，它应该返回一个数组[13,13,3,7,31]，而不是 def primeFactorization(x): i=2 array=[] for i in range(i,x+1): if x % i == 0: j=2 for j in range(j,x+1): if i % j ==

我迷路了。我的函数在某些情况下有效，但在某些情况下不起作用。例如，提供数字110019时，它应该返回一个数组[13,13,3,7,31]，而不是

def primeFactorization(x):
    i=2
    array=[]
    for i in range(i,x+1):
        if x % i == 0:
            j=2
            for j in range(j,x+1):
                if i % j == 0:
                i=j
            array.append(i)
            product_value=1
            for j in array:
                product_value=j*product_value
                if product_value == x:
                    array.sort()
                    return array
    return []

问题是你的逻辑太复杂了，你会被自己绊倒。特别是，您识别因素的次数太多。因此，当您迭代嵌套循环时，因子列表（您将其命名为

array

）中存在一些因子的副本，因此该列表的乘积永远不是原始数。因此，您永远不会对数组进行排序并返回数组，而是退出到函数的最后一行，返回空列表

尝试使用已知的正确方法之一，而不是此算法。最重要的是，当您找到一个因子并将其放入列表中时，将

除以该因子，然后继续对商进行因子分解。你的逻辑问题源于对原始数字的操作，然后试图确定你找到的因子的新成分是否正确

以下是您的代码和一些基本的跟踪打印：

def primeFactorization(x):
    i=2
    array=[]
    for i in range(i,x+1):
        if x % i == 0:
            print x, "divisible by", i
            j = 2
            for j in range(j,x+1):
                if i % j == 0:
                    print i, "divisible by", j, "resetting"
                    i = j
            array.append(i)
            print "New factor", array
            product_value = 1
            for j in array:
                product_value = j*product_value
                if product_value == x:
                    array.sort()
                    return array
    return []

print primeFactorization(110019)

输出：

110019 divisible by 3
3 divisible by 3 resetting
New factor [3]
110019 divisible by 7
7 divisible by 7 resetting
New factor [3, 7]
110019 divisible by 13
13 divisible by 13 resetting
New factor [3, 7, 13]
110019 divisible by 21
21 divisible by 3 resetting
New factor [3, 7, 13, 3]
110019 divisible by 31
31 divisible by 31 resetting
New factor [3, 7, 13, 3, 31]
110019 divisible by 39
39 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3]
110019 divisible by 91
91 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7]
110019 divisible by 93
93 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3]
110019 divisible by 169
169 divisible by 13 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13]
110019 divisible by 217
217 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7]
110019 divisible by 273
273 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3]
110019 divisible by 403
403 divisible by 13 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13]
110019 divisible by 507
507 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3]
110019 divisible by 651
651 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3]
110019 divisible by 1183
1183 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7]
110019 divisible by 1209
1209 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3]
110019 divisible by 2821
2821 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7]
110019 divisible by 3549
3549 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3]
110019 divisible by 5239
5239 divisible by 13 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13]
110019 divisible by 8463
8463 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13, 3]
110019 divisible by 15717
15717 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13, 3, 3]
110019 divisible by 36673
36673 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13, 3, 3, 7]
110019 divisible by 110019
110019 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13, 3, 3, 7, 3]
[]

问题是你的逻辑太复杂了，你会被自己绊倒。特别是，您识别因素的次数太多。因此，当您迭代嵌套循环时，因子列表（您将其命名为

array

尝试使用已知的正确方法之一，而不是此算法。最重要的是，当您找到一个因子并将其放入列表中时，将

除以该因子，然后继续对商进行因子分解。你的逻辑问题源于对原始数字的操作，然后试图确定你找到的因子的新成分是否正确

以下是您的代码和一些基本的跟踪打印：

def primeFactorization(x):
    i=2
    array=[]
    for i in range(i,x+1):
        if x % i == 0:
            print x, "divisible by", i
            j = 2
            for j in range(j,x+1):
                if i % j == 0:
                    print i, "divisible by", j, "resetting"
                    i = j
            array.append(i)
            print "New factor", array
            product_value = 1
            for j in array:
                product_value = j*product_value
                if product_value == x:
                    array.sort()
                    return array
    return []

print primeFactorization(110019)

输出：

110019 divisible by 3
3 divisible by 3 resetting
New factor [3]
110019 divisible by 7
7 divisible by 7 resetting
New factor [3, 7]
110019 divisible by 13
13 divisible by 13 resetting
New factor [3, 7, 13]
110019 divisible by 21
21 divisible by 3 resetting
New factor [3, 7, 13, 3]
110019 divisible by 31
31 divisible by 31 resetting
New factor [3, 7, 13, 3, 31]
110019 divisible by 39
39 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3]
110019 divisible by 91
91 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7]
110019 divisible by 93
93 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3]
110019 divisible by 169
169 divisible by 13 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13]
110019 divisible by 217
217 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7]
110019 divisible by 273
273 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3]
110019 divisible by 403
403 divisible by 13 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13]
110019 divisible by 507
507 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3]
110019 divisible by 651
651 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3]
110019 divisible by 1183
1183 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7]
110019 divisible by 1209
1209 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3]
110019 divisible by 2821
2821 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7]
110019 divisible by 3549
3549 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3]
110019 divisible by 5239
5239 divisible by 13 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13]
110019 divisible by 8463
8463 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13, 3]
110019 divisible by 15717
15717 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13, 3, 3]
110019 divisible by 36673
36673 divisible by 7 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13, 3, 3, 7]
110019 divisible by 110019
110019 divisible by 3 resetting
New factor [3, 7, 13, 3, 31, 3, 7, 3, 13, 7, 3, 13, 3, 3, 7, 3, 7, 3, 13, 3, 3, 7, 3]
[]

一些问题：

上的循环没有任何作用。只有当

i==j

时，

if

中的

才是真的，因为在那之后j
只会增加。此外，赋值i=j
不会改变任何内容，因为当这种情况发生时，它们已经相等了


您的代码永远不能两次附加相同的值，但这可能是必要的
每次从头开始计算产品都会浪费时间。您应该在附加新因子时以增量方式执行此操作。最好是从相反的方向进行计算，然后将x
除以找到的每个因子。这样你就避免了寻找非主要因素
对列表进行排序是没有用的，因为i
增加了您的代码，所以当您将i
附加到列表中时，列表将始终保持排序


以下是它的工作原理：
def primeFactorization(x):
    lst = []
    i = 2
    while x > 1:
        while x % i == 0:
            lst.append(i)
            x //= i
        i += 1
    return lst

print (primeFactorization(110019))

一些问题：

j
上的循环没有任何作用。只有当i==j
时，if
中的才是真的，因为在那之后j
只会增加。此外，赋值i=j
不会改变任何内容，因为当这种情况发生时，它们已经相等了

您的代码永远不能两次附加相同的值，但这可能是必要的
每次从头开始计算产品都会浪费时间。您应该在附加新因子时以增量方式执行此操作。最好是从相反的方向进行计算，然后将x
除以找到的每个因子。这样你就避免了寻找非主要因素
对列表进行排序是没有用的，因为i
增加了您的代码，所以当您将i
附加到列表中时，列表将始终保持排序

以下是它的工作原理：
def primeFactorization(x):
    lst = []
    i = 2
    while x > 1:
        while x % i == 0:
            lst.append(i)
            x //= i
        i += 1
    return lst

print (primeFactorization(110019))

您使用的不是数组，而是列表。您试图实现的逻辑是什么？你有算法的来源吗。它实际上没有什么意义。在迭代时修改列表总是一个坏主意，不要使用数组。将排序到数组中的j的循环中我正在尝试找到该数字的所有因子。我的第一个循环是通过从2到我们试图找到因子的值的每个值。第二个循环是把4变成2，6变成2，9变成3。任何作为因子的数字，我们都要把它变成素数，再次从2开始，循环遍历这些数字。不幸的是，这不起作用。对于每一个除x的数i
，包括x本身，您可以识别除i
的最低素数j
。这不会产生x
的素因子分解。在线研究素数因子分解的基本算法。你不是在使用数组，而是在使用列表。你想要实现的逻辑是什么？你有算法的来源吗。它实际上没有什么意义。在迭代时修改列表总是一个坏主意，不要使用数组。将排序到数组中的j的循环中我正在尝试找到该数字的所有因子。我的第一个循环是通过从2到我们试图找到因子的值的每个值。第二个循环是把4变成2，6变成2，9变成3。任何作为因子的数字，我们都要把它变成素数，再次从2开始，循环遍历这些数字。不幸的是，这不起作用。对于每一个除x的数i
，包括x本身，您可以识别除i
的最低素数j
。这不会产生x
的素因子分解。在线研究素数因子分解的基本算法。现在我们得到了所有的因子。显然是重复的。但是，w