GFG App
Open App
Browser
Continue

Find two numbers whose difference of fourth power is equal to N

Given an integer N, the task is to find two non-negative integers X and Y such that X4 – Y4 = N. If no such pair exists, print -1.

Examples:

Input: N = 15
Output: X = 2, Y = 1
Explanation:
X4 – Y4 = (2)4 – (1)4 = (16) – (1) = 15

Input: N = 10
Output: -1
Explanation :
No such value of X and Y are there which satisfy the condition.

Approach:
To solve the problem mentioned above, we have to observe that we need to find the minimum and the maximum values of x and y that is possible to satisfy the equation.

• The minimum value for the two integers can be 0 since X & Y are non-negative.
• The maximum value of X and Y can be ceil(N(1/4)).
• Hence, iterate over the range [0, ceil(N(1/4))] and find any suitable pair of X and Y that satisfies the condition.

Below is the implementation of the above approach:

C++

 `// C++ implementation to find the` `// values of x and y for the given` `// equation with integer N`   `#include ` `using` `namespace` `std;`   `// Function which find required x & y` `void` `solve(``int` `n)` `{` `    ``// Upper limit of x & y,` `    ``// if such x & y exists` `    ``int` `upper_limit = ``ceil``(``pow``(` `        ``n, 1.0 / 4));`   `    ``for` `(``int` `x = 0; x <= upper_limit; x++) {`   `        ``for` `(``int` `y = 0; y <= upper_limit; y++) {`   `            ``// num1 stores x^4` `            ``int` `num1 = x * x * x * x;`   `            ``// num2 stores y^4` `            ``int` `num2 = y * y * y * y;`   `            ``// If condition is satisfied` `            ``// the print and return` `            ``if` `(num1 - num2 == n) {` `                ``cout << ``"x = "` `<< x` `                     ``<< ``", y = "` `<< y;` `                ``return``;` `            ``}` `        ``}` `    ``}`   `    ``// If no such pair exists` `    ``cout << -1 << endl;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `n = 15;`   `    ``solve(n);`   `    ``return` `0;` `}`

Java

 `// Java implementation to find the` `// values of x and y for the given` `// equation with integer N` `import` `java.util.*;`   `class` `GFG{`   `// Function which find required x & y` `static` `void` `solve(``int` `n)` `{` `    `  `    ``// Upper limit of x & y,` `    ``// if such x & y exists` `    ``int` `upper_limit = (``int``) (Math.ceil` `                            ``(Math.pow(n, ``1.0` `/ ``4``)));`   `    ``for``(``int` `x = ``0``; x <= upper_limit; x++)` `    ``{` `       ``for``(``int` `y = ``0``; y <= upper_limit; y++) ` `       ``{` `          `  `          ``// num1 stores x^4` `          ``int` `num1 = x * x * x * x;` `          `  `          ``// num2 stores y^4` `          ``int` `num2 = y * y * y * y;` `          `  `          ``// If condition is satisfied` `          ``// the print and return` `          ``if` `(num1 - num2 == n) ` `          ``{` `              ``System.out.print(``"x = "` `+ x +` `                             ``", y = "` `+ y);` `              ``return``;` `          ``}` `       ``}` `    ``}` `    `  `    ``// If no such pair exists` `    ``System.out.print(-``1``);` `}`   `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``15``;`   `    ``solve(n);` `}` `}`   `// This code is contributed by shivanisinghss2110`

Python3

 `# Python3 implementation to find the` `# values of x and y for the given` `# equation with integer N` `from` `math ``import` `pow``, ceil`   `# Function which find required x & y` `def` `solve(n) :`   `    ``# Upper limit of x & y,` `    ``# if such x & y exists` `    ``upper_limit ``=` `ceil(``pow``(n, ``1.0` `/` `4``));`   `    ``for` `x ``in` `range``(upper_limit ``+` `1``) :`   `        ``for` `y ``in` `range``(upper_limit ``+` `1``) :`   `            ``# num1 stores x^4` `            ``num1 ``=` `x ``*` `x ``*` `x ``*` `x;`   `            ``# num2 stores y^4` `            ``num2 ``=` `y ``*` `y ``*` `y ``*` `y;`   `            ``# If condition is satisfied` `            ``# the print and return` `            ``if` `(num1 ``-` `num2 ``=``=` `n) :` `                ``print``(``"x ="``, x, ``", y ="` `, y);` `                ``return``;`   `    ``# If no such pair exists` `    ``print``(``-``1``) ;`   `# Driver code` `if` `__name__ ``=``=` `"__main__"` `:`   `    ``n ``=` `15``;`   `    ``solve(n);` `    `  `# This code is contributed by AnkitRai01`

C#

 `// C# implementation to find the` `// values of x and y for the given` `// equation with integer N` `using` `System;`   `class` `GFG{`   `// Function which find required x & y` `static` `void` `solve(``int` `n)` `{` `    `  `    ``// Upper limit of x & y,` `    ``// if such x & y exists` `    ``int` `upper_limit = (``int``) (Math.Ceiling` `                            ``(Math.Pow(n, 1.0 / 4)));`   `    ``for``(``int` `x = 0; x <= upper_limit; x++)` `    ``{` `       ``for``(``int` `y = 0; y <= upper_limit; y++) ` `       ``{` `          `  `          ``// num1 stores x^4` `          ``int` `num1 = x * x * x * x;` `          `  `          ``// num2 stores y^4` `          ``int` `num2 = y * y * y * y;` `          `  `          ``// If condition is satisfied` `          ``// the print and return` `          ``if` `(num1 - num2 == n) ` `          ``{` `              ``Console.Write(``"x = "` `+ x +` `                          ``", y = "` `+ y);` `              ``return``;` `          ``}` `       ``}` `    ``}` `    `  `    ``// If no such pair exists` `    ``Console.Write(-1);` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `n = 15;`   `    ``solve(n);` `}` `}`   `// This code is contributed by shivanisinghss2110`

Javascript

 ``

Output

`x = 2, y = 1`

Time Complexity: O(sqrt(N))
Auxiliary space: O(1)

Another Approach:

In this implementation, we create an unordered map (hash table) to store the values of x^4 – n for each x from 0 to the upper limit. Then, we iterate through the possible values of y and check if y^4 – n is already in the hash table. If it is, we retrieve the corresponding value of x and print the solution. If no such pair exists, we print -1.

C++

 `#include ` `using` `namespace` `std;`   `void` `solve(``int` `n) {` `    ``unordered_map<``int``, ``int``> hashTable;`   `    ``// Calculate upper limit of x & y` `    ``int` `upper_limit = ``ceil``(``pow``(n, 1.0/4));`   `    ``// Store x^4 - n in hash table` `    ``for` `(``int` `x = 0; x <= upper_limit; x++) {` `        ``int` `x4 = x * x * x * x;` `        ``hashTable[x4 - n] = x;` `    ``}`   `    ``// Check if there is a y such that y^4 - x^4 = n` `    ``for` `(``int` `y = 0; y <= upper_limit; y++) {` `        ``int` `y4 = y * y * y * y;` `        ``if` `(hashTable.find(y4) != hashTable.end()) {` `            ``int` `x = hashTable[y4];` `            ``cout << ``"x = "` `<< x << ``", y = "` `<< y << endl;` `            ``return``;` `        ``}` `    ``}`   `    ``// If no such pair exists` `    ``cout << -1 << endl;` `}`   `int` `main() {` `    ``int` `n = 15;`   `    ``solve(n);`   `    ``return` `0;` `}`

Output

```x = 2, y = 1
```

Time Complexity: O(N^(1/4))
Auxiliary space: O(N^(1/4))

My Personal Notes arrow_drop_up