编译时Python卡住

Question

I have written a program that finds the smallest number that has every number from 1 to 20 as a multiple. My code in C++ works perfectly and finds the correct answer:

#include <iostream>

using namespace std;

int main(){

    for( int i = 1; i < 300000000; i++ ){

        int check = 1;

        for( int j = 6; j <= 20; j++ ){

            if( i % j == 0 ){

                continue;

            } else {

                check = 0;
                break;

            }

        }

        if( check == 1 ){

            cout << i << endl;
            break;

        }

    }

}

However, the same program in Python - which works when finding the smallest number with all of 1 to 10 as multiples, but only if the range being searched is smaller (it works with 5000000) - simply will not compile. I goes on forever and I have to close the Terminal window.

for i in range( 1, 300000000 ):

    check = 1

    for j in range( 6, 21 ):
        if i % j == 0:
            continue
        else:
            check = 0
            break

    if check == 1:
        print i
        break

I am using Mac OS X Mavericks, if this is relevant.

Edit: I have tried switching to xrange, but this regrettably makes no difference.

Edit2: I left it on in the background - it did in fact just take about 14 minutes to run! I apologise, I should have done this in the first instance.

Answer 1

I guess you are using Python 2.

Your problem is this:

range( 1, 300000000 )

You are building a list of 300000000 Python int objects. If we assume that ints in Python are 4-bytes (which is tremendously false), then you are allocating 300000000 × 4 = 1200000000 bytes = 1 GB.

You should replace it with the following:

xrange( 1, 300000000 )

The advantage of xrange is that it does not pre-allocate all the Python ints in advance. See the documentation of xrange for more information:

The advantage of xrange() over range() is minimal [...] except when a very large range is used on a memory-starved machine [...]

With Python 3 this problem does no longer exist, because range has been removed and xrange has been renamed to range .

Note that this will solve any memory error you would encounter. This won't solve the problem of using a bad, slow algorithm. Python is not really speedy when dealing with numbers (but also other languages will perform slowly when using huge numbers).

Answer 2

What do you mean "compile"? How are you compiling Python code?

Try using xrange()

Answer 3

If this is python 2 then you really need to change the range to xrange . range works by creating a list of the size specified which you are then iterating over item by item. However in this case you don't need the list itself, only the indexes which were contained in that list. So you should prefer xrange because it is a generator which means that it can iterate without creating a list in memory. This will save your program from having to create a really large list which will take up a lot of memory.

Note that in Python 3 range has the same behaviour that Python 2 xrange had.

for i in xrange( 1, 300000000 ):

    check = 1

    for j in xrange( 6, 21 ):
        if i % j == 0:
            continue
        else:
            check = 0
            break

    if check == 1:
        print i
        break

Also Python is an interpreted language, there is no compile step like there is in c++. What you are seeing is just a slow running time.

Answer 4

Your Python program is not wrong , it is just very very slow because you are using a very bad algorithm.

Try this instead:

def gcd(a, b):
    while b:
        a, b = b, a%b
    return a

def lcm(a, b):
    return (a // gcd(a, b)) * b

res = 1
for i in range(2, 21):
    res = lcm(res, i)
print("Least common multiple of 1..20 is {}".format(res))

Edit: alternatively, you can use your algorithm (but make it about 400x faster) by realizing that 19 and 20 are relatively prime, therefore any solution must be a multiple of 19 * 20:

UPTO = 300000000
STEP = 19 * 20

for i in xrange(STEP, UPTO, STEP):
    if any(i % div for div in xrange(6, 19)):
        continue
    else:
        print("Solution: {}".format(i))
        break

which runs in about 0.94 s on my machine (vs. 0.0000249 s for the "good" algorithm == about 37,000 times faster again!).