mirror of
https://github.com/TheAlgorithms/Python.git
synced 2024-12-18 01:00:15 +00:00
62dcbea943
* Add powersum problem * Add doctest * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Add more doctests * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Add more doctests * Improve paramater name * Fix line too long * Remove global variables * Apply suggestions from code review * Apply suggestions from code review --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> Co-authored-by: Christian Clauss <cclauss@me.com>
94 lines
2.6 KiB
Python
94 lines
2.6 KiB
Python
"""
|
|
Problem source: https://www.hackerrank.com/challenges/the-power-sum/problem
|
|
Find the number of ways that a given integer X, can be expressed as the sum
|
|
of the Nth powers of unique, natural numbers. For example, if X=13 and N=2.
|
|
We have to find all combinations of unique squares adding up to 13.
|
|
The only solution is 2^2+3^2. Constraints: 1<=X<=1000, 2<=N<=10.
|
|
"""
|
|
|
|
from math import pow
|
|
|
|
|
|
def backtrack(
|
|
needed_sum: int,
|
|
power: int,
|
|
current_number: int,
|
|
current_sum: int,
|
|
solutions_count: int,
|
|
) -> tuple[int, int]:
|
|
"""
|
|
>>> backtrack(13, 2, 1, 0, 0)
|
|
(0, 1)
|
|
>>> backtrack(100, 2, 1, 0, 0)
|
|
(0, 3)
|
|
>>> backtrack(100, 3, 1, 0, 0)
|
|
(0, 1)
|
|
>>> backtrack(800, 2, 1, 0, 0)
|
|
(0, 561)
|
|
>>> backtrack(1000, 10, 1, 0, 0)
|
|
(0, 0)
|
|
>>> backtrack(400, 2, 1, 0, 0)
|
|
(0, 55)
|
|
>>> backtrack(50, 1, 1, 0, 0)
|
|
(0, 3658)
|
|
"""
|
|
if current_sum == needed_sum:
|
|
# If the sum of the powers is equal to needed_sum, then we have a solution.
|
|
solutions_count += 1
|
|
return current_sum, solutions_count
|
|
|
|
i_to_n = int(pow(current_number, power))
|
|
if current_sum + i_to_n <= needed_sum:
|
|
# If the sum of the powers is less than needed_sum, then continue adding powers.
|
|
current_sum += i_to_n
|
|
current_sum, solutions_count = backtrack(
|
|
needed_sum, power, current_number + 1, current_sum, solutions_count
|
|
)
|
|
current_sum -= i_to_n
|
|
if i_to_n < needed_sum:
|
|
# If the power of i is less than needed_sum, then try with the next power.
|
|
current_sum, solutions_count = backtrack(
|
|
needed_sum, power, current_number + 1, current_sum, solutions_count
|
|
)
|
|
return current_sum, solutions_count
|
|
|
|
|
|
def solve(needed_sum: int, power: int) -> int:
|
|
"""
|
|
>>> solve(13, 2)
|
|
1
|
|
>>> solve(100, 2)
|
|
3
|
|
>>> solve(100, 3)
|
|
1
|
|
>>> solve(800, 2)
|
|
561
|
|
>>> solve(1000, 10)
|
|
0
|
|
>>> solve(400, 2)
|
|
55
|
|
>>> solve(50, 1)
|
|
Traceback (most recent call last):
|
|
...
|
|
ValueError: Invalid input
|
|
needed_sum must be between 1 and 1000, power between 2 and 10.
|
|
>>> solve(-10, 5)
|
|
Traceback (most recent call last):
|
|
...
|
|
ValueError: Invalid input
|
|
needed_sum must be between 1 and 1000, power between 2 and 10.
|
|
"""
|
|
if not (1 <= needed_sum <= 1000 and 2 <= power <= 10):
|
|
raise ValueError(
|
|
"Invalid input\n"
|
|
"needed_sum must be between 1 and 1000, power between 2 and 10."
|
|
)
|
|
|
|
return backtrack(needed_sum, power, 1, 0, 0)[1] # Return the solutions_count
|
|
|
|
|
|
if __name__ == "__main__":
|
|
import doctest
|
|
|
|
doctest.testmod()
|