algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-06 17:29:31 +08:00
Code Issues Packages Projects Releases Wiki Activity

Improve power sum algorithm (#5652)

Browse Source 
* Update directory

* Improve PowerSum algorithm implementation and documentation

This commit enhances the PowerSum class in the backtracking package. The changes focus on improving code quality, readability, and documentation. Key improvements include:

1. Enhanced code structure and efficiency:
   - Removed class-level variables for better thread safety
   - Optimized the recursive approach to avoid unnecessary calculations
   - Simplified the overall logic for easier understanding

2. Improved readability:
   - Used more descriptive variable names (e.g., 'targetSum' instead of 'n', 'power' instead of 'x')
   - Enhanced method structure with a private recursive helper method

3. Better documentation:
   - Added comprehensive JavaDoc comments explaining the algorithm's purpose and implementation
   - Clarified the meaning of parameters, especially relating them to the original problem statement (N and X)
   - Improved inline comments for better code understanding

4. Adhered to Java best practices:
   - Improved encapsulation by making the recursive method private
   - Used Math.pow() directly instead of a custom power method

5. Maintained core functionality:
   - The algorithm still solves the same problem as before, but with improved code quality

* updated PowerSum

* Refactor PowerSum algorithm implementation and documentation

* Refactor PowerSum algorithm implementation and documentation

* Refactor code formatting and remove unnecessary line in PowerSum.java

* Refactor code formatting and add newline at end of file in .clang-format

---------

Co-authored-by: manishraj27 <manishraj27@users.noreply.github.com>
Co-authored-by: Bama Charan Chhandogi <b.c.chhandogi@gmail.com>
This commit is contained in:
Manish Raj
2024-10-08 23:59:29 +05:30
committed by GitHub
parent d437d581f4
commit f3b2a94e74
1 changed files with 41 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
src/main/java/com/thealgorithms/backtracking/PowerSum.java
View File

@ -1,45 +1,51 @@
package com.thealgorithms.backtracking;
/*
/**
* Problem Statement:
* Find the number of ways that a given integer, N, can be expressed as the sum of the Xth powers
* of unique, natural numbers. For example, if N=100 and X=3, we have to find all combinations of
* unique cubes adding up to 100. The only solution is 1^3+2^3+3^3+4^3. Therefore output will be 1.
* of unique, natural numbers.
* For example, if N=100 and X=3, we have to find all combinations of unique cubes adding up to 100.
* The only solution is 1^3 + 2^3 + 3^3 + 4^3. Therefore, the output will be 1.
*
* N is represented by the parameter 'targetSum' in the code.
* X is represented by the parameter 'power' in the code.
*/
public class PowerSum {
private int count = 0;
private int sum = 0;
public int powSum(int n, int x) {
sum(n, x, 1);
return count;
/**
* Calculates the number of ways to express the target sum as a sum of Xth powers of unique natural numbers.
*
* @param targetSum The target sum to achieve (N in the problem statement)
* @param power The power to raise natural numbers to (X in the problem statement)
* @return The number of ways to express the target sum
*/
public int powSum(int targetSum, int power) {
// Special case: when both targetSum and power are zero
if (targetSum == 0 && power == 0) {
return 1; // by convention, one way to sum to zero: use nothing
}
return sumRecursive(targetSum, power, 1, 0);
}
// here i is the natural number which will be raised by X and added in sum.
public void sum(int n, int x, int i) {
// if sum is equal to N that is one of our answer and count is increased.
if (sum == n) {
count++;
return;
} // we will be adding next natural number raised to X only if on adding it in sum the
// result is less than N.
else if (sum + power(i, x) <= n) {
sum += power(i, x);
sum(n, x, i + 1);
// backtracking and removing the number added last since no possible combination is
// there with it.
sum -= power(i, x);
}
if (power(i, x) < n) {
// calling the sum function with next natural number after backtracking if when it is
// raised to X is still less than X.
sum(n, x, i + 1);
/**
* Recursively calculates the number of ways to express the remaining sum as a sum of Xth powers.
*
* @param remainingSum The remaining sum to achieve
* @param power The power to raise natural numbers to (X in the problem statement)
* @param currentNumber The current natural number being considered
* @param currentSum The current sum of powered numbers
* @return The number of valid combinations
*/
private int sumRecursive(int remainingSum, int power, int currentNumber, int currentSum) {
int newSum = currentSum + (int) Math.pow(currentNumber, power);
if (newSum == remainingSum) {
return 1;
}
if (newSum > remainingSum) {
return 0;
}
// creating a separate power function so that it can be used again and again when required.
private int power(int a, int b) {
return (int) Math.pow(a, b);
return sumRecursive(remainingSum, power, currentNumber + 1, newSum) + sumRecursive(remainingSum, power, currentNumber + 1, currentSum);
}
}