 Open in App
Not now

# Find ways an Integer can be expressed as sum of n-th power of unique natural numbers

• Difficulty Level : Hard
• Last Updated : 27 Apr, 2022

Given two numbers x and n, find a number of ways x can be expressed as sum of n-th power of unique natural numbers.

Examples :

Input  : x = 10, n = 2
Output : 1
Explanation: 10 = 12 + 32, Hence total 1 possibility

Input  : x = 100, n = 2
Output : 3
Explanation:
100 = 102 OR 62 + 82 OR 12 + 32 + 42 + 52 + 72 Hence total 3 possibilities

The idea is simple. We iterate through all number starting from 1. For every number, we recursively try all greater numbers and if we are able to find sum, we increment result

## C++

 `// C++ program to count number of ways any` `// given integer x can be expressed as n-th` `// power of unique natural numbers.` `#include ` `using` `namespace` `std;`   `// Function to calculate and return the` `// power of any given number` `int` `power(``int` `num, unsigned ``int` `n)` `{` `    ``if` `(n == 0)` `        ``return` `1;` `    ``else` `if` `(n % 2 == 0)` `        ``return` `power(num, n / 2) * power(num, n / 2);` `    ``else` `        ``return` `num * power(num, n / 2) * power(num, n / 2);` `}`   `// Function to check power representations recursively` `int` `checkRecursive(``int` `x, ``int` `n, ``int` `curr_num = 1,` `                   ``int` `curr_sum = 0)` `{` `    ``// Initialize number of ways to express` `    ``// x as n-th powers of different natural` `    ``// numbers` `    ``int` `results = 0;`   `    ``// Calling power of 'i' raised to 'n'` `    ``int` `p = power(curr_num, n);` `    ``while` `(p + curr_sum < x) {` `        ``// Recursively check all greater values of i` `        ``results += checkRecursive(x, n, curr_num + 1,` `                                  ``p + curr_sum);` `        ``curr_num++;` `        ``p = power(curr_num, n);` `    ``}`   `    ``// If sum of powers is equal to x` `    ``// then increase the value of result.` `    ``if` `(p + curr_sum == x)` `        ``results++;`   `    ``// Return the final result` `    ``return` `results;` `}`   `// Driver Code.` `int` `main()` `{` `    ``int` `x = 10, n = 2;` `    ``cout << checkRecursive(x, n);` `    ``return` `0;` `}`

## Java

 `// Java program to count number of ways any` `// given integer x can be expressed as n-th` `// power of unique natural numbers.`   `class` `GFG {`   `    ``// Function to calculate and return the` `    ``// power of any given number` `    ``static` `int` `power(``int` `num, ``int` `n)` `    ``{` `        ``if` `(n == ``0``)` `            ``return` `1``;` `        ``else` `if` `(n % ``2` `== ``0``)` `            ``return` `power(num, n / ``2``) * power(num, n / ``2``);` `        ``else` `            ``return` `num * power(num, n / ``2``)` `                ``* power(num, n / ``2``);` `    ``}`   `    ``// Function to check power representations recursively` `    ``static` `int` `checkRecursive(``int` `x, ``int` `n, ``int` `curr_num,` `                              ``int` `curr_sum)` `    ``{` `        ``// Initialize number of ways to express` `        ``// x as n-th powers of different natural` `        ``// numbers` `        ``int` `results = ``0``;`   `        ``// Calling power of 'i' raised to 'n'` `        ``int` `p = power(curr_num, n);` `        ``while` `(p + curr_sum < x) {` `            ``// Recursively check all greater values of i` `            ``results += checkRecursive(x, n, curr_num + ``1``,` `                                      ``p + curr_sum);` `            ``curr_num++;` `            ``p = power(curr_num, n);` `        ``}`   `        ``// If sum of powers is equal to x` `        ``// then increase the value of result.` `        ``if` `(p + curr_sum == x)` `            ``results++;`   `        ``// Return the final result` `        ``return` `results;` `    ``}`   `    ``// Driver Code.` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `x = ``10``, n = ``2``;` `        ``System.out.println(checkRecursive(x, n, ``1``, ``0``));` `    ``}` `}`   `// This code is contributed by mits`

## Python3

 `# Python3 program to count number of ways any` `# given integer x can be expressed as n-th` `# power of unique natural numbers.`   `# Function to calculate and return the` `# power of any given number`     `def` `power(num, n):`   `    ``if``(n ``=``=` `0``):` `        ``return` `1` `    ``elif``(n ``%` `2` `=``=` `0``):` `        ``return` `power(num, n ``/``/` `2``) ``*` `power(num, n ``/``/` `2``)` `    ``else``:` `        ``return` `num ``*` `power(num, n ``/``/` `2``) ``*` `power(num, n ``/``/` `2``)`   `# Function to check power representations recursively`     `def` `checkRecursive(x, n, curr_num``=``1``, curr_sum``=``0``):`   `    ``# Initialize number of ways to express` `    ``# x as n-th powers of different natural` `    ``# numbers` `    ``results ``=` `0`   `    ``# Calling power of 'i' raised to 'n'` `    ``p ``=` `power(curr_num, n)` `    ``while``(p ``+` `curr_sum < x):`   `        ``# Recursively check all greater values of i` `        ``results ``+``=` `checkRecursive(x, n, curr_num ``+` `1``, p ``+` `curr_sum)` `        ``curr_num ``=` `curr_num ``+` `1` `        ``p ``=` `power(curr_num, n)`   `    ``# If sum of powers is equal to x` `    ``# then increase the value of result.` `    ``if``(p ``+` `curr_sum ``=``=` `x):` `        ``results ``=` `results ``+` `1`   `    ``# Return the final result` `    ``return` `results`     `# Driver Code.` `if` `__name__ ``=``=` `'__main__'``:` `    ``x ``=` `10` `    ``n ``=` `2` `    ``print``(checkRecursive(x, n))`     `# This code is contributed by` `# Sanjit_Prasad`

## C#

 `// C# program to count number of ways any` `// given integer x can be expressed as` `// n-th power of unique natural numbers.` `using` `System;`   `class` `GFG {`   `    ``// Function to calculate and return` `    ``// the power of any given number` `    ``static` `int` `power(``int` `num, ``int` `n)` `    ``{` `        ``if` `(n == 0)` `            ``return` `1;` `        ``else` `if` `(n % 2 == 0)` `            ``return` `power(num, n / 2) * power(num, n / 2);` `        ``else` `            ``return` `num * power(num, n / 2)` `                ``* power(num, n / 2);` `    ``}`   `    ``// Function to check power` `    ``// representations recursively` `    ``static` `int` `checkRecursive(``int` `x, ``int` `n, ``int` `curr_num,` `                              ``int` `curr_sum)` `    ``{` `        ``// Initialize number of ways to express` `        ``// x as n-th powers of different natural` `        ``// numbers` `        ``int` `results = 0;`   `        ``// Calling power of 'i' raised to 'n'` `        ``int` `p = power(curr_num, n);` `        ``while` `(p + curr_sum < x) {` `            ``// Recursively check all greater values of i` `            ``results += checkRecursive(x, n, curr_num + 1,` `                                      ``p + curr_sum);` `            ``curr_num++;` `            ``p = power(curr_num, n);` `        ``}`   `        ``// If sum of powers is equal to x` `        ``// then increase the value of result.` `        ``if` `(p + curr_sum == x)` `            ``results++;`   `        ``// Return the final result` `        ``return` `results;` `    ``}`   `    ``// Driver Code.` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `x = 10, n = 2;` `        ``System.Console.WriteLine(` `            ``checkRecursive(x, n, 1, 0));` `    ``}` `}`   `// This code is contributed by mits`

## PHP

 ``

## Javascript

 ``

Output

`1`

Alternate Solution :

Below is an alternate simpler solution provided by Shivam Kanodia.

## C++

 `// C++ program to find number of ways to express ` `// a number as sum of n-th powers of numbers.` `#include` `using` `namespace` `std;`   `int` `res = 0;` `int` `checkRecursive(``int` `num, ``int` `x, ``int` `k, ``int` `n)` `{` `    ``if` `(x == 0) ` `        ``res++;` `    `  `    ``int` `r = (``int``)``floor``(``pow``(num, 1.0 / n));`   `    ``for` `(``int` `i = k + 1; i <= r; i++) ` `    ``{` `        ``int` `a = x - (``int``)``pow``(i, n);` `        ``if` `(a >= 0)` `            ``checkRecursive(num, x - ` `                          ``(``int``)``pow``(i, n), i, n);` `    ``}` `    ``return` `res;` `}`   `// Wrapper over checkRecursive()` `int` `check(``int` `x, ``int` `n)` `{` `    ``return` `checkRecursive(x, x, 0, n);` `}`   `// Driver Code` `int` `main()` `{ ` `    ``cout << (check(10, 2));` `    ``return` `0;` `}`   `// This code is contributed by mits`

## C

 `// C program to find number of ways to express` `// a number as sum of n-th powers of numbers.` `#include ` `#include `   `int` `res = 0;` `int` `checkRecursive(``int` `num, ``int` `x, ``int` `k, ``int` `n)` `{` `    ``if` `(x == 0)` `        ``res++;`   `    ``int` `r = (``int``)``floor``(``pow``(num, 1.0 / n));`   `    ``for` `(``int` `i = k + 1; i <= r; i++) {` `        ``int` `a = x - (``int``)``pow``(i, n);` `        ``if` `(a >= 0)` `            ``checkRecursive(num, x - (``int``)``pow``(i, n), i, n);` `    ``}` `    ``return` `res;` `}`   `// Wrapper over checkRecursive()` `int` `check(``int` `x, ``int` `n)` `{` `    ``return` `checkRecursive(x, x, 0, n);` `}`   `// Driver Code` `int` `main()` `{` `    ``printf``(``"%d"``, (check(10, 2)));` `    ``return` `0;` `}`   `// This code is contributed by Rohit Pradhan`

## Java

 `// Java program to find number of ways to express a` `// number as sum of n-th powers of numbers.` `import` `java.io.*;` `import` `java.util.*;`   `public` `class` `Solution {`   `    ``static` `int` `res = ``0``;` `    ``static` `int` `checkRecursive(``int` `num, ``int` `x, ``int` `k, ``int` `n)` `    ``{` `        ``if` `(x == ``0``) ` `            ``res++;` `        `  `        ``int` `r = (``int``)Math.floor(Math.pow(num, ``1.0` `/ n));`   `        ``for` `(``int` `i = k + ``1``; i <= r; i++) {` `            ``int` `a = x - (``int``)Math.pow(i, n);` `          ``if` `(a >= ``0``)` `            ``checkRecursive(num, ` `                   ``x - (``int``)Math.pow(i, n), i, n);` `        ``}` `        ``return` `res;` `    ``}` `    `  `    ``// Wrapper over checkRecursive()` `    ``static` `int` `check(``int` `x, ``int` `n)` `    ``{` `        ``return` `checkRecursive(x, x, ``0``, n);` `    ``}`   `    ``public` `static` `void` `main(String[] args)` `    ``{ ` `        ``System.out.println(check(``10``, ``2``));` `    ``}` `}`

## Python3

 `# Python 3 program to find number of ways to express` `# a number as sum of n-th powers of numbers.`     `def` `checkRecursive(num, rem_num, next_int, n, ans``=``0``):`   `    ``if` `(rem_num ``=``=` `0``):` `        ``ans ``+``=` `1`   `    ``r ``=` `int``(num``*``*``(``1` `/` `n))`   `    ``for` `i ``in` `range``(next_int ``+` `1``, r ``+` `1``):` `        ``a ``=` `rem_num ``-` `int``(i``*``*``n)` `        ``if` `a >``=` `0``:` `            ``ans ``+``=` `checkRecursive(num, rem_num ``-` `int``(i``*``*``n), i, n, ``0``)` `    ``return` `ans`   `# Wrapper over checkRecursive()`     `def` `check(x, n):` `    ``return` `checkRecursive(x, x, ``0``, n)`     `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``print``(check(``10``, ``2``))`   `# This code is contributed by` `# Surendra_Gangwar`

## C#

 `// C# program to find number of` `// ways to express a number as sum` `// of n-th powers of numbers.` `using` `System;`   `class` `Solution {`   `    ``static` `int` `res = 0;` `    ``static` `int` `checkRecursive(``int` `num, ``int` `x,` `                                ``int` `k, ``int` `n)` `    ``{` `        ``if` `(x == 0) ` `            ``res++;` `        `  `        ``int` `r = (``int``)Math.Floor(Math.Pow(num, 1.0 / n));`   `        ``for` `(``int` `i = k + 1; i <= r; i++) ` `        ``{` `            ``int` `a = x - (``int``)Math.Pow(i, n);` `        ``if` `(a >= 0)` `            ``checkRecursive(num, x - ` `                          ``(``int``)Math.Pow(i, n), i, n);` `        ``}` `        ``return` `res;` `    ``}` `    `  `    ``// Wrapper over checkRecursive()` `    ``static` `int` `check(``int` `x, ``int` `n)` `    ``{` `        ``return` `checkRecursive(x, x, 0, n);` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `Main()` `    ``{ ` `        ``Console.WriteLine(check(10, 2));` `    ``}` `}`   `// This code is contributed by vt_m.`

## PHP

 `= 0)` `            ``checkRecursive(``\$num``, ``\$x` `- ` `                    ``(int)pow(``\$i``, ``\$n``), ` `                             ``\$i``, ``\$n``);` `    ``}` `    ``return` `\$res``;` `}`   `// Wrapper over` `// checkRecursive()` `function` `check(``\$x``, ``\$n``)` `{` `    ``return` `checkRecursive(``\$x``, ``\$x``, ` `                          ``0, ``\$n``);` `}`   `// Driver Code` `echo` `(check(10, 2));`   `// This code is contributed by ajit` `?>`

## Javascript

 ``

Output

`1`

Simple Recursive Solution:

contributed by Ram Jondhale.

## C++

 `#include ` `#include` `using` `namespace` `std;`   `//Helper function` `int` `getAllWaysHelper(``int` `remainingSum, ``int` `power, ``int` `base){` `      ``//calculate power` `    ``int` `result = ``pow``(base, power);` `      `  `    ``if``(remainingSum == result)` `        ``return` `1;` `    ``if``(remainingSum < result)` `        ``return` `0;` `      ``//Two recursive calls one to include current base's power in sum another to exclude` `    ``int` `x = getAllWaysHelper(remainingSum - result, power, base + 1);` `    ``int` `y = getAllWaysHelper(remainingSum, power, base+1);` `    ``return` `x + y;` `}`   `int` `getAllWays(``int` `sum, ``int` `power) {` `    ``return` `getAllWaysHelper(sum, power, 1);` `}`   `// Driver Code.` `int` `main()` `{` `    ``int` `x = 10, n = 2;` `    ``cout << getAllWays(x, n);` `    ``return` `0;` `}`

## Java

 `// Java program to implement the approach` `import` `java.io.*;`   `class` `GFG {`   `  ``public` `static` `int` `getAllWaysHelper(``int` `remainingSum,` `                                     ``int` `power, ``int` `base)` `  ``{` `    ``// calculate power` `    ``int` `result = (``int``)Math.pow(base, power);`   `    ``if` `(remainingSum == result)` `      ``return` `1``;` `    ``if` `(remainingSum < result)` `      ``return` `0``;` `    ``// Two recursive calls one to include current base's` `    ``// power in sum another to exclude` `    ``int` `x = getAllWaysHelper(remainingSum - result,` `                             ``power, base + ``1``);` `    ``int` `y = getAllWaysHelper(remainingSum, power,` `                             ``base + ``1``);` `    ``return` `x + y;` `  ``}`   `  ``public` `static` `int` `getAllWays(``int` `sum, ``int` `power)` `  ``{` `    ``return` `getAllWaysHelper(sum, power, ``1``);` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `main(String[] args)` `  ``{` `    ``int` `x = ``10``, n = ``2``;` `    ``System.out.print(getAllWays(x, n));` `  ``}` `}`   `// This code is contributed by Rohit Pradhan`

## Python3

 `# Helper function` `def` `getAllWaysHelper(remainingSum, power, base):`   `    ``# calculate power` `    ``result ``=` `pow``(base, power)` `    `  `    ``if``(remainingSum ``=``=` `result):` `        ``return` `1` `    ``if``(remainingSum < result):` `        ``return` `0` `        `  `    ``# Two recursive calls one to include ` `    ``# current base's power in sum another to exclude` `    ``x ``=` `getAllWaysHelper(remainingSum ``-` `result, power, base ``+` `1``)` `    ``y ``=` `getAllWaysHelper(remainingSum, power, base``+``1``)` `    ``return` `x ``+` `y`   `def` `getAllWays(``sum``, power):` `    ``return` `getAllWaysHelper(``sum``, power, ``1``)`   `# Driver Code` `x,n ``=` `10``,``2` `print``(getAllWays(x, n))`   `# This code is contributed by shinjanpatra.`

## C#

 `using` `System;` `class` `GFG {`   `    ``// Helper function` `    ``static` `int` `getAllWaysHelper(``int` `remainingSum, ``int` `power,` `                                ``int` `bases)` `    ``{` `        ``// calculate power` `        ``int` `result = (``int``)Math.Pow(bases, power);`   `        ``if` `(remainingSum == result)` `            ``return` `1;` `        ``if` `(remainingSum < result)` `            ``return` `0;` `        ``// Two recursive calls one to include current base's` `        ``// power in sum another to exclude` `        ``int` `x = getAllWaysHelper(remainingSum - result,` `                                 ``power, bases + 1);` `        ``int` `y = getAllWaysHelper(remainingSum, power,` `                                 ``bases + 1);` `        ``return` `x + y;` `    ``}`   `    ``static` `int` `getAllWays(``int` `sum, ``int` `power)` `    ``{` `        ``return` `getAllWaysHelper(sum, power, 1);` `    ``}`   `    ``// Driver Code.` `    ``public` `static` `int` `Main()` `    ``{` `        ``int` `x = 10, n = 2;` `        ``Console.Write(getAllWays(x, n));` `        ``return` `0;` `    ``}` `}`   `// This code is contributed by Taranpreet`

## Javascript

 ``

Output

`1`

This article is contributed by DANISH KALEEM. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.