如何改进此代码以提高时间效率？ For循环，素数

Question

The task was taken from www.codewars.com

The prime numbers are not regularly spaced. For example from 2 to 3 the step is 1. From 3 to 5 the step is 2. From 7 to 11 it is 4. Between 2 and 50 we have the following pairs of 2-steps primes:

3, 5 - 5, 7, - 11, 13, - 17, 19, - 29, 31, - 41, 43

We will write a function step with parameters:

g (integer >= 2) which indicates the step we are looking for,

m (integer >= 2) which gives the start of the search (m inclusive),

n (integer >= m) which gives the end of the search (n inclusive)

In the example above step(2, 2, 50) will return [3, 5] which is the first pair between 2 and 50 with a 2-steps.

So this function should return the first pair of the two prime numbers spaced with a step of g between the limits m, n if these g-steps prime numbers exist otherwise nil or null or None or Nothing or [] or "0, 0" or {0, 0} or 0 0(depending on the language).

Examples: step(2, 5, 7) --> [5, 7] or (5, 7) or {5, 7} or "5 7"

step(2, 5, 5) --> nil or... or [] in Ocaml or {0, 0} in C++

step(4, 130, 200) --> [163, 167] or (163, 167) or {163, 167}

See more examples for your language in "TESTS"

Remarks: ([193, 197] is also such a 4-steps primes between 130 and 200 but it's not the first pair).

step(6, 100, 110) --> [101, 107] though there is a prime between 101 and 107 which is 103; the pair 101-103 is a 2-step.

Here is my solution, which works perfectly and takes more than it requires to test out, however, I'm trying to optimize this code in order to make it more time-efficient.

def step(g,m,n):

    count = 0
    list= []
    list2 = []
    for num in range(m,n+1):
        if all(num%i!=0 for i in range(2,num)):
            count += 1
            list.append(num)
    

        
    for k in list:
        for q in list:
            if (q-k) > 0:
                if (q-k) == g:
                    list2.append(k)
                    list2.append(q)
            

                
    if not list2:
         return 
    else:
         return  [list2[0],list2[1]]

If you have any suggestions or even sample code, I would appreciate this.

Answer 1

First things first, never use keywords as variables .

To come with a better approach, you need to think the flaws in your approach.

1. You're iterating through all numbers to determine the prime numbers.
2. You're iterating through the list in O(n**2) to find if a pair exists with the required difference.
3. Your algorithm for prime number calculation is not optimal.

For the 1st point, it is not even required to find all the primes in a given range, as your task to find first pair with the required difference . So, if you find number a as a prime and a + g also a prime, then you found the solution already.

For the 2nd point, you can simply iterate through the list, and check if (k + g) in list to find if you've found the pair.

For the 3rd point, you can found an optimal implementation on the wikipedia page itself. If you can understand the logic, then you may write that implementation yourself very easily.

So, combining an optimal prime checking implementation with a single loop iteration, the solution can be easily written as shown below.

from functools import lru_cache

@lru_cache(None)
def is_prime(n):
    if n <= 3:
        return n > 1
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i ** i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True


def step(g, m, n):
    for i in range(m, n + 1 - g):
        if is_prime(i) and is_prime(i + g):
            return [i, i + g]
    return

This implementation took only 1.32 sec for 1,000,000 iterations for step(4, 130, 200) . As you can see, the logic is very simple once you implement the is_prime function.