我怎样才能使这个完美平方和函数更有效？

Question

Part of my homework involves making a function which checks if a number is a sum of two squares. Problem is that it takes a very long time for larger numbers to run through it. Any suggestions on how to make this more efficient? for example, given the number 50 it would return (7,1) since 7^2 is 49 and 1^2 is 1 so the total would be 50 Here's the code:

def sum_of_squares(n) : 
  i = 1 

  while i * i <= n : 
      j = 1

      while(j * j <= n) : 

          while (i * i + j * j == n) : 

              return (j,i)

          j = j + 1
      i = i + 1

Answer 1

def sum_of_squares(n) :
  range = round(math.sqrt(n)) 
  i = 1 
  while i <= round(range/2) : 
      j = range;

      while(j >= round(range/2)) : 

          while (i * i + j * j == n) : 

              return (j,i)

          j = j - 1
      i = i + 1

Answer 2

A modification of algorithm from https://www.geeksforgeeks.org/check-whether-number-can-represented-sum-two-squares/

1. Method 1--saves squares in a dictionary for later lookup
2. Method 2--computes integer square root using binary search
3. Method 3--checks if the number is a perfect square by using math.sqrt function

Method 1

The technique is basically to loop through numbers from 0 to sqrt(n), storing the squares i * i as dictionary key, with i as value.

If number (n - i * i) already in the dictionary, then you have found a pair (i & d[n - i * i].

Returns the solution with the max tuple value.

Algorithm complexity O(sqrt(n)).

def sum_square(n): 
  d = {}
  maxi = None
  for i in range(n): 
    if i * i > n: 
      break
      # store squared value with value in dictionary 
    d[i*i] = i  # saving the square root of i*i as i

    try:
      k = d[n - i*i]      # check if n- i*i is already in a key
      if maxi:
        maxi = max(maxi, (i, k))    # update max solution
      else:
        maxi = (i, k)               # first solution
    except:
      continue

  return maxi

Method 2

def sum_square_binary(n): 
  def binary_search(start_, end_, val): 
    # If lower limit exceeds   
    # upper limit.  
    if start_ > end_: 
        return None 

    # Calculating mid.  
    mid = start_ + (end_ - start_) // 2 

    if mid * mid == val:
        return mid 

    if mid * mid > val: 
        return binary_search(start_, mid - 1, val)

    return binary_search(mid + 1, end_, val)

  maxi = None

  for i in range(n):
      if i*i > n:
          break

      b = n - i * i 

      # Use binary search to see if b is a perfect square
      # only need to check range [0, b] in binary search
      k = binary_search(0, b, b)  # k is the root of b (if perfect square)
      if k:
          maxi = max(maxi, (i, k), key = max) if maxi else (i, k)

  return (max(maxi), min(maxi)) if maxi else maxi

Method 3

import math

def sum_square_sqrt(n):
  def integer_sqrt(x): 
      """ Returns sqrt of integer if it is a perfect square.  
          Uses technique from Cook https://www.johndcook.com/blog/2008/11/17/fast-way-to-test-whether-a-number-is-a-square/ to reduce the number of times sqrt is called """
      # Find the floating point value of  
      # square root of x. 
      h = x & 0xF
      if h > 9:
          return None
      if ( h != 2 and h != 3 and h != 5 and h != 6 and h != 7 and h != 8 ):
          sr = math.sqrt(x) 

          # If square root is an integer 
          return int(sr) if ((sr - math.floor(sr)) == 0) else None
      else:
          return None

  maxi = None

  for i in range(n):
      if i*i > n:
          break

      b = n - i * i 

      # Use binary search to see if b is a perfect square
      # only need to check range [0, b] in binary search
      k = integer_sqrt(b)  # k is the root of b (if perfect square)
      if k:
          maxi = max(maxi, (i, k), key = max) if maxi else (i, k)

  return (max(maxi), min(maxi)) if maxi else maxi

Performance

Method 1 using a dictionary is much faster, with Method 3 comparable. Method 3 should be okay until the sqrt becomes inaccurate as a test for larger n.

tst = [randint(1e6, 1e9) for _ in range(10)]

%timeit for k in tst: sum_square(k)

>>>Method 1: 180 ms ± 14.7 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit for k in tst: sum_square_binary(k)

>>>Method 2: 4.04 s ± 97.1 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

%timeit for k in tst: sum_square_sqrt(k)

>>>Method 3: 192 ms ± 5.66 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Answer 3

You could use dynamic programming, to prevent squares from being recalculated over and over. By using a keeping track of a list of outcomes you can just look up the value. If the value is not defined yet, you just calculate it once, if it has been calculated before, you just return the corresponding entry in the list instead of recalculating:

squares = []

def get_square(x):
    global squares

    if(squares[x] == -1):
        squares[x] = x * x

    return squares[x]

def sum_of_squares(n):
    global squares
    squares = [-1 for i in range(n)]

    i = 1
    while get_square(i) <= n - 1: 
        j = 1
        while(get_square(j) <= n - 1) :
            if(get_square(i) + get_square(j) == n) :
                return (j,i)
            j = j + 1
        i = i + 1

print(sum_of_squares(25))

Answer 4

As some others suggested above, preventing the computation of squares in each iteration is a good start. Here is a simple implementation using for loops :

def sum_of_squares(n):
     lim = int(n**0.5)+1
     for i in range(1, lim):
             for j in range(1,i):
                     if(i**2 + j**2==n):
                             return (i,j)