Question

我有此代码：

def has_divisors(n, i=2):
    """
    Check if a number is prime or not
    :param n: Number to check
    :param i: Increasing value that tries to divide
    :return: True if prime, False if not
    """
    if n <= 1:
        return False
    if i + 1 == n:
        return True
    if n <= 2 and n > 0:
        return True
    if n % i == 0:
        return False
    return has_divisors(n, i + 1)

告诉数字质数是否为质数，问题在于它可以在输入最大递归深度错误之后检查数字质数是否为+-1500。有谁知道如何提高此代码的效率（我不想要完全不同的代码，是的，我知道递归对该功能不是一个好主意，但我必须使用它）谢谢！

Answer 1

我实际上通过添加一个条件来提高了效率：

real3 bodyBodyInteraction(real iPosx, real iPosy, real iPosz, 
                          real jPosx, real jPosy, real jPosz, real jMass)
{
  real rx, ry, rz;

  rx = jPosx - iPosx;
  ry = jPosy - iPosy;
  rz = jPosz - iPosz;

  real distSqr = rx*rx+ry*ry+rz*rz;
  distSqr += SOFTENING_SQUARED;


   real s = jMass / POW(distSqr,3.0/2.0); //very expensive

  real3 f;
  f.x = rx * s;
  f.y = ry * s;
  f.z = rz * s;

  return f;
}

感谢所有尝试提供帮助的人。

Answer 2

修改DataFrame.swaplevel中的功能

这应该具有最大递归部> 1M

两项改进：仅进入sqrt（N），并且仅检查奇数。

def has_divisors(N, i=3):
  if N <= 2:
      return False
  elif N % 2 == 0:  # even
      return True
  elif i * i > N:  # tried all divisors to sqrt, 
                   # must be prime
      return False

  elif (N % i) == 0:  # i is a divisor
    return True
  else:  # recursively try the next ( odd) divisor
      return has_divisors(N, i + 2)

Answer 3

您不需要对每次递归进行基本的取消资格测试，因此为了提高效率，根据您的要求，我将其转换为：

def has_no_divisors(n):

    if n <= 2 or n % 2 == 0:
        return n == 2

    def has_no_divisors_recursive(n, i=3):

        if i * i > n:
            return True

        if n % i == 0:
            return False

        return has_no_divisors_recursive(n, i + 2)

    return has_no_divisors_recursive(n)

通过将2作为一种特殊情况，并仅测试除以奇数，这还应该具有修改后的代码的两倍性能（堆栈使用量的一半）。

如何使此递归函数对质数更加有效

3 个答案: