# Find Cube Pairs | Set 1 (A n^(2/3) Solution)

Given a number n, find two pairs that can represent the number as sum of two cubes. In other words, find two pairs (a, b) and (c, d) such that given number n can be expressed as

```n = a^3 + b^3 = c^3 + d^3
```

where a, b, c and d are four distinct numbers.

Examples:

```Input: N = 1729
Output: (1, 12) and (9, 10)
Explanation:
1729 = 1^3 + 12^3 = 9^3 + 10^3

Input: N = 4104
Output: (2, 16) and (9, 15)
Explanation:
4104 = 2^3 + 16^3 = 9^3 + 15^3

Input: N = 13832
Output: (2, 24) and (18, 20)
Explanation:
13832 = 2^3 + 24^3 = 18^3 + 20^3

```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Any number n that satisfies the constraint will have two distinct pairs (a, b) and (c, d) such that a, b, c and d are all less than n1/3. The idea is very simple. For every distinct pair (x, y) formed by numbers less than the n1/3, if their sum (x3 + y3) is equal to given number, we store them in a hash table using sum as a key. If pairs with sum equal to given number appears again, we simply print both pairs.

```1) Create an empty hash map, say s.
2) cubeRoot = n1/3
3) for (int x = 1; x < cubeRoot; x++)
for (int y = x + 1; y <= cubeRoot; y++)
int sum = x3 + y3;
if (sum != n) continue;
if sum exists in s,
we found two pairs with sum, print the pairs
else
insert pair(x, y) in s using sum as key
```

Below is the implementation of above idea –

## CPP

 `// C++ program to find pairs that can represent ` `// the given number as sum of two cubes ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find pairs that can represent ` `// the given number as sum of two cubes ` `void` `findPairs(``int` `n) ` `{ ` `    ``// find cube root of n ` `    ``int` `cubeRoot = ``pow``(n, 1.0/3.0); ` ` `  `    ``// create an empty map ` `    ``unordered_map<``int``, pair<``int``, ``int``> > s; ` ` `  `    ``// Consider all pairs such with values less ` `    ``// than cuberoot ` `    ``for` `(``int` `x = 1; x < cubeRoot; x++) ` `    ``{ ` `        ``for` `(``int` `y = x + 1; y <= cubeRoot; y++) ` `        ``{ ` `            ``// find sum of current pair (x, y) ` `            ``int` `sum = x*x*x + y*y*y; ` ` `  `            ``// do nothing if sum is not equal to ` `            ``// given number ` `            ``if` `(sum != n) ` `                ``continue``; ` ` `  `            ``// if sum is seen before, we found two pairs ` `            ``if` `(s.find(sum) != s.end()) ` `            ``{ ` `                ``cout << ``"("` `<< s[sum].first << ``", "` `                     ``<< s[sum].second << ``") and ("` `                    ``<< x << ``", "` `<< y << ``")"` `<< endl; ` `            ``} ` `            ``else` `                ``// if sum is seen for the first time ` `                ``s[sum] = make_pair(x, y); ` `        ``} ` `    ``} ` `} ` ` `  `// Driver function ` `int` `main() ` `{ ` `    ``int` `n = 13832; ` `    ``findPairs(n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to find pairs that can represent ` `// the given number as sum of two cubes ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `    ``static` `class` `pair ` `    ``{  ` `        ``int` `first, second;  ` `        ``public` `pair(``int` `first, ``int` `second)  ` `        ``{  ` `            ``this``.first = first;  ` `            ``this``.second = second;  ` `        ``}  ` `    ``} ` `     `  `// Function to find pairs that can represent ` `// the given number as sum of two cubes ` `static` `void` `findPairs(``int` `n) ` `{ ` `    ``// find cube root of n ` `    ``int` `cubeRoot = (``int``) Math.pow(n, ``1.0``/``3.0``); ` ` `  `    ``// create an empty map ` `    ``HashMap s = ``new` `HashMap(); ` ` `  `    ``// Consider all pairs such with values less ` `    ``// than cuberoot ` `    ``for` `(``int` `x = ``1``; x < cubeRoot; x++) ` `    ``{ ` `        ``for` `(``int` `y = x + ``1``; y <= cubeRoot; y++) ` `        ``{ ` `            ``// find sum of current pair (x, y) ` `            ``int` `sum = x*x*x + y*y*y; ` ` `  `            ``// do nothing if sum is not equal to ` `            ``// given number ` `            ``if` `(sum != n) ` `                ``continue``; ` ` `  `            ``// if sum is seen before, we found two pairs ` `            ``if` `(s.containsKey(sum)) ` `            ``{ ` `                ``System.out.print(``"("` `+ s.get(sum).first+ ``", "` `                    ``+ s.get(sum).second+ ``") and ("` `                    ``+ x+ ``", "` `+ y+ ``")"` `+``"\n"``); ` `            ``} ` `            ``else` `                ``// if sum is seen for the first time ` `                ``s.put(sum, ``new` `pair(x, y)); ` `        ``} ` `    ``} ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``13832``; ` `    ``findPairs(n); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

## C#

 `// C# program to find pairs that can represent ` `// the given number as sum of two cubes ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG ` `{ ` `    ``class` `pair ` `    ``{  ` `        ``public` `int` `first, second;  ` `        ``public` `pair(``int` `first, ``int` `second)  ` `        ``{  ` `            ``this``.first = first;  ` `            ``this``.second = second;  ` `        ``}  ` `    ``} ` `      `  `// Function to find pairs that can represent ` `// the given number as sum of two cubes ` `static` `void` `findPairs(``int` `n) ` `{ ` `    ``// find cube root of n ` `    ``int` `cubeRoot = (``int``) Math.Pow(n, 1.0/3.0); ` `  `  `    ``// create an empty map ` `    ``Dictionary<``int``, pair> s = ``new` `Dictionary<``int``, pair>(); ` `  `  `    ``// Consider all pairs such with values less ` `    ``// than cuberoot ` `    ``for` `(``int` `x = 1; x < cubeRoot; x++) ` `    ``{ ` `        ``for` `(``int` `y = x + 1; y <= cubeRoot; y++) ` `        ``{ ` `            ``// find sum of current pair (x, y) ` `            ``int` `sum = x*x*x + y*y*y; ` `  `  `            ``// do nothing if sum is not equal to ` `            ``// given number ` `            ``if` `(sum != n) ` `                ``continue``; ` `  `  `            ``// if sum is seen before, we found two pairs ` `            ``if` `(s.ContainsKey(sum)) ` `            ``{ ` `                ``Console.Write(``"("` `+ s[sum].first+ ``", "` `                    ``+ s[sum].second+ ``") and ("` `                    ``+ x+ ``", "` `+ y+ ``")"` `+``"\n"``); ` `            ``} ` `            ``else` `                ``// if sum is seen for the first time ` `                ``s.Add(sum, ``new` `pair(x, y)); ` `        ``} ` `    ``} ` `} ` `  `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `n = 13832; ` `    ``findPairs(n); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```(2, 24) and (18, 20)
```

Time Complexity of above solution is O(n2/3) which is much less than O(n).

Can we solve the above problem in O(n1/3) time? We will be discussing that in next post.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Improved By : princiraj1992

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.