Add num_perfect_squares keon#767 (keon#848)

* Added num_perfect_squares

* Added final test for increased coverage

* Fix requested changes for issue keon#767.

Also improved documentation and added 1 test case.

* Doc update to clarify intent for issue keon#767

This documentation update clarifies the intent and order of each code piece.

Co-authored-by: unknown <[email protected]>
Co-authored-by: ntomsic <[email protected]>
Co-authored-by: Keon <[email protected]>

Author: 3 people

README.md

@@ -225,6 +225,7 @@ If you want to uninstall algorithms, it is as simple as:
     - [next_bigger](algorithms/maths/next_bigger.py)
     - [next_perfect_square](algorithms/maths/next_perfect_square.py)
     - [nth_digit](algorithms/maths/nth_digit.py)
+    - [num_perfect_squares](algorithms/maths/num_perfect_squares.py)
     - [polynomial](algorithms/maths/polynomial.py)
     - [power](algorithms/maths/power.py)
     - [prime_check](algorithms/maths/prime_check.py)

algorithms/maths/__init__.py

@@ -25,3 +25,4 @@
 from .power import *
 from .magic_number import *
 from .krishnamurthy_number import *
+from .num_perfect_squares import *

algorithms/maths/num_perfect_squares.py

@@ -0,0 +1,47 @@
+"""
+Given an integer num_perfect_squares will return the minimum amount of perfect squares are required
+to sum to the specified number. Lagrange's four-square theorem gives us that the answer will always
+be between 1 and 4 (https://en.wikipedia.org/wiki/Lagrange%27s_four-square_theorem).
+
+Some examples:
+Number | Perfect Squares representation | Answer
+-------|--------------------------------|--------
+9      | 3^2                            | 1
+10     | 3^2 + 1^2                      | 2
+12     | 2^2 + 2^2 + 2^2                | 3
+31     | 5^2 + 2^2 + 1^2 + 1^2          | 4
+"""
+
+import math
+
+def num_perfect_squares(number):
+    """
+    Returns the smallest number of perfect squares that sum to the specified number.
+    :return: int between 1 - 4
+    """
+    # If the number is a perfect square then we only need 1 number.
+    if int(math.sqrt(number))**2 == number:
+        return 1
+
+    # We check if https://en.wikipedia.org/wiki/Legendre%27s_three-square_theorem holds and divide
+    # the number accordingly. Ie. if the number can be written as a sum of 3 squares (where the
+    # 0^2 is allowed), which is possible for all numbers except those of the form: 4^a(8b + 7).
+    while number > 0 and number % 4 == 0:
+        number /= 4
+
+    # If the number is of the form: 4^a(8b + 7) it can't be expressed as a sum of three (or less
+    # excluding the 0^2) perfect squares. If the number was of that form, the previous while loop
+    # divided away the 4^a, so by now it would be of the form: 8b + 7. So check if this is the case
+    # and return 4 since it neccessarily must be a sum of 4 perfect squares, in accordance 
+    # with https://en.wikipedia.org/wiki/Lagrange%27s_four-square_theorem.
+    if number % 8 == 7:
+        return 4
+
+    # By now we know that the number wasn't of the form 4^a(8b + 7) so it can be expressed as a sum
+    # of 3 or less perfect squares. Try first to express it as a sum of 2 perfect squares, and if
+    # that fails, we know finally that it can be expressed as a sum of 3 perfect squares.
+    for i in range(1, int(math.sqrt(number)) + 1):
+        if int(math.sqrt(number - i**2))**2 == number - i**2:
+            return 2
+
+    return 3

tests/test_maths.py

@@ -24,6 +24,7 @@
     find_primitive_root,
     num_digits,
     diffie_hellman_key_exchange, krishnamurthy_number,
+    num_perfect_squares,
     chinese_remainder_theorem,
 )
 
@@ -502,6 +503,25 @@ def test_num_digits(self):
         self.assertEqual(3, num_digits(-254))
 
 
+
+class TestNumberOfPerfectSquares(unittest.TestCase):
+    """[summary]
+    Test for the file num_perfect_squares.py
+
+    Arguments:
+        unittest {[type]} -- [description]
+    """
+    def test_num_perfect_squares(self):
+        self.assertEqual(4,num_perfect_squares(31))
+        self.assertEqual(3,num_perfect_squares(12))
+        self.assertEqual(2,num_perfect_squares(13))
+        self.assertEqual(2,num_perfect_squares(10))
+        self.assertEqual(4,num_perfect_squares(1500))        
+        self.assertEqual(2,num_perfect_squares(1548524521))
+        self.assertEqual(3,num_perfect_squares(9999999993))
+        self.assertEqual(1,num_perfect_squares(9))
+
+
 class TestChineseRemainderSolver(unittest.TestCase):
     def test_k_three(self):
         # Example which should give the answer 143