从列表中删除是列表中任何其他数字的倍数的数字的最佳方法是什么

Question

I was attempting to generalize an optimal answer to Problem 1 on Project Euler , and realized that while using the inclusion/exclusion method, the answer comes out wrong if you enter in a list where one of the numbers is a multiple of any of the other numbers in the list.

For example, with a limit of 1000, and a list of [3, 5, 6, 8], the answer comes out as 306004, but the answer SHOULD come out as 266824. This is because 6 is a multiple of 3, and needs to be removed.

I came up with the following code to remove extraneous multiples from a list:

def cleanMults(mults):
    m = sorted(mults)
    x = [m[0]]
    for i in range(len(m) - 1, 0, -1):
        multFound = False
        for j in range(i - 1, -1, -1):
            if m[i] % m[j] == 0: 
                multFound = True
                break
        if multFound == False: x.append(m[i])
    return sorted(x)

Here I'm sorting the list (just in case it's out of order), then starting with the last element in the list, comparing every element to every other element. If an element being divided by another element results in a remainder of 0, then we set multFound = True, break, and don't add it to the solution list. Otherwise, if no divisor is found, we do add it to the list.

My question is, is there a more optimized way to do this? Even ignoring the sort, this runs in O(n^2) time. I know there is a way to compare two lists in O(n log(n)) time, but this isn't quite the same thing as that. Anybody have any ideas or solutions here?

Answer 1

At the very least, you need to collect all of the numbers, de-duplicate, sort, and then check lower numbers against higher ones. There are tricks you can use to streamline the process; you can make bit maps, check primality, etc. However, you still have an inherently O(N^2) process.

However, the faster way to solve the original problem is to take the sums of the individual arithmetic sequences:

min3 = 3
max3 = (1000 // 3) * 3
cnt3 = max3 // 3
sum3 = (min3 + max3) * cnt3/ 2

min5 = 5
max5 = (1000 // 5) * 5
cnt5 = max5 // 5
sum5 = (min5 + max5) * cnt5 / 2

Now, since you've double-counted everything with both factors, you need to subtract the extra instance of multiples of 15. Compute sum15 in the same fashion.

Finally:

total = sum3 + sum5 - sum15

To generalize this to even more factors, composite numbers must be subtracted k-1 times, where k is the quantity of factors. Generalizing this for your general case may give you a solution more time-efficient than removing multiples.

In short, doing the direct sequence computations greatly lowers the cost of having extra factors.

Does that get you moving?

Answer 2

Here's what I currently have:

import time 
from math import prod 
from itertools import combinations as co 

def SoM(lim, mul): 
    n = (lim - 1) //mul 
    return (n * (n + 1) * mul) // 2 

def inex(lim, mults): 
    ans = 0 
    for i in range(len(mults)): 
        for j in co(mults, i + 1): 
            ans += (-1)**i * SoM(lim, prod(list(j))) 
    return ans

def cleanMults(mults):
    m = sorted(mults)
    x = [m[0]]
    for i in range(len(m) - 1, 0, -1):
        multFound = False
        for j in range(i - 1, -1, -1):
            if m[i] % m[j] == 0: multFound = True
        if multFound == False: x.append(m[i])
    return sorted(x)

def toString(mults):
    if len(mults) == 1: return str(list(mults)[0])
    s = 'or ' + str(list(mults)[-1])
    for i in range(len(mults) - 2, -1, -1):
        s = str(list(mults)[i]) + ', ' + s
    return s

def SumOfMults(lim, mults):
    #Declare variables
    start = time.time()
    strnums, m = '', cleanMults(mults)

    #Solve the problem
    ans = str(inex(lim, m))
        
    #Print the results
    print('The sum of all of the multiples of ')
    print(toString(mults) + ' below ' + str(lim) + ' is ' + ans + '.')
    print('This took ' + str(time.time() - start) + ' seconds to calculate.')

I'm assuming there are no duplicates, though if there are, all I have to do is cast the list to a set, then back to a list again.

You say that:

"To generalize this to even more factors, composite numbers must be subtracted k-1 times, where k is the quantity of factors."

Can you go into a little more detail of what you mean, with examples?

In an example like the list [3, 5, 26], the 26 is a composite number, and it only has 2 factors (2, and 13), so if I'm understanding correctly, the sum of all factors of 26 up to the limit needs to be subtracted from the total once?

With my logic, I do currently do the following:

sum3 + sum5 + sum26 - sum78 (26 * 3) - sum130 (26 * 5) - sum15 (3 * 5) + sum1170 (3 * 5 * 26).

Are you suggesting there is a more efficient way to calculate this?

Answer 3

You can use the gcd function going forward and backward once through the list. This will allow you to identify the divisors (eg 3) for which there is at least one multiple in the list. You can then filter the list based on these divisors.

from math import gcd
def cleanMult(A):
    divisors = []
    for d in (1,-1):
        seen = 1
        for a in A[::d]:
            if seen%a: seen = a*seen//gcd(a,seen)
            else:      divisors.append(a)                    
    return [a for a in A if all(d==a or a%d for d in divisors)]

print(cleanMult([3,5,6,8]))
# [3, 5, 8]

print(cleanMult([6,5,9,15,16,12,8]))
# [6, 5, 9, 8]

However, for Euler problem one, there is a much simple way to get the answer:

sum(n for n in range(1,100) if n%5==0 or n%3==0)

You can also generate all multiples and place them in a set to only count them once each:

multiset = set()
N = 1000
for f in [3,5,6,8]:
    multiset.update(range(f,N,f))
total = sum(multiset)
# 266824

or get some inspiration from the sieve or Eratosthenes:

N=1000
sieve = [0]*N
for f in [3,5,6,8]:
    sieve[f::f] = range(f,N,f)
total = sum(sieve)
# 266824