# Count of pairs in an Array whose sum is a Perfect Cube

Given an array arr of distinct elements of size N, the task is to find the total number of pairs in the array whose sum is a perfect cube.
Examples:

Input: arr[] = {2, 3, 6, 9, 10, 20}
Output:
Only possible pair is (2, 6)
Input: arr[] = {9, 2, 5, 1}
Output:

Naive Approach: Use nested loops and check every possible pair for whether their sum is a perfect cube or not. This technique is not effective when the length of the array is very large.
Efficient Approach:

• Store all the elements of the array in a HashSet and save the sum of the maximum two elements in a variable named max.
• It is clear that the sum of any two elements from the array will not exceed max. So, find all the perfect cubes which are max and save it in an ArrayList named perfectcubes.
• Now for every element in the array say arr[i] and for every perfect cube saved in perfectcubes, check whether perfectcubes.get(i) â€“ arr[i] exists in nums or not i.e. if there is any element in the original array that when added with the currently chosen element gives any perfect cube from the list.
• If the above condition is satisfied, increment the count variable.
• Print the value of count in the end.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include` `#include` `using` `namespace` `std;`   `// Function to return an ArrayList containing ` `// all the perfect cubes upto n ` `vector<``int``> getPerfectcubes(``int` `n)` `{`   `    ``vector<``int``>perfectcubes; ` `    ``int` `current = 1; ` `    ``int` `i = 1; `   `    ``// while current perfect cube is ` `    ``// less than or equal to n ` `    ``while` `(current <= n)` `    ``{` `        ``perfectcubes.push_back(current); ` `        ``i += 1; ` `        ``current = ``int``(``pow``(i, 3)); ` `    ``}` `    ``return` `perfectcubes; ` `} `   `// Function to print the sum of maximum ` `// two elements from the array ` `int` `maxPairSum(``int` `arr[],``int` `n)` `{`   `    ``int` `max = 0; ` `    ``int` `secondMax = 0; ` `    ``if` `(arr[0] > arr[1])` `    ``{` `        ``max = arr[0]; ` `        ``secondMax = arr[1]; ` `    ``}` `    ``else` `    ``{` `        ``max = arr[1]; ` `        ``secondMax = arr[0]; ` `    ``}` `    ``for` `(``int` `i = 2; i < n; i++)` `    ``{` `        ``if` `(arr[i] > max)` `        ``{` `            ``secondMax = max; ` `            ``max = arr[i]; ` `        ``}` `        ``else` `if` `(arr[i] > secondMax)` `            ``secondMax = arr[i]; ` `    ``}` `    ``return` `(max + secondMax); ` `}`   `// Function to return the count of numbers that ` `// when added with n give a perfect cube ` `int` `countPairsWith(``int` `n, vector<``int``> perfectcubes, vector<``int``> nums)` `{`   `    ``int` `count = 0; ` `    ``int` `len=perfectcubes.size();` `    ``for` `(``int` `i = 0; i < len; i++)` `    ``{` `        ``int` `temp = perfectcubes[i] - n; `   `        ``// temp > n is checked so that pairs ` `        ``// (x, y) and (y, x) don't get counted twice ` `        ``if` `(temp > n)` `        ``{` `            ``for``(``auto` `j=nums.begin();j!=nums.end();j++)` `            ``{` `                ``if``((*j)==temp)` `                    ``count += 1; ` `            ``}` `        ``}` `    ``} ` `    ``return` `count; ` `}`   `// Function to count the pairs whose ` `// sum is a perfect cube ` `int` `countPairs(``int` `arr[],``int` `n)` `{`   `    ``// Sum of the maximum two elements ` `    ``// from the array ` `    ``int` `max = maxPairSum(arr,n); `   `    ``// List of perfect cubes upto max ` `    ``vector<``int``>perfectcubes = getPerfectcubes(max); `   `    ``// Contains all the array elements ` `    ``vector<``int``>nums; ` `    ``for` `(``int` `i = 0 ; i < n; i++) ` `        ``nums.push_back(arr[i]);`   `    ``int` `count = 0; ` `    ``for` `(``int` `i = 0; i < n; i++)` `    ``{`   `        ``// Add count of the elements that when ` `        ``// added with arr[i] give a perfect cube ` `        ``count += countPairsWith(arr[i], perfectcubes, nums); ` `    ``}` `    ``return` `count; `   `}`   `// Driver code ` `int` `main()` `{` `    ``int` `arr[] = { 2, 6, 18, 9, 999, 1 }; ` `    ``int` `n=``sizeof``(arr)/``sizeof``(arr[0]);` `    ``cout<<(countPairs(arr,n)); ` `    `  `}`   `// This code is contributed by chitranayal`

## Java

 `// Java implementation of the approach` `import` `java.util.*;`   `class` `GFG ` `{`   `    ``// Function to return an ArrayList containing` `    ``// all the perfect cubes upto n` `    ``static` `List getPerfectcubes(``int` `n) {`   `        ``List perfectcubes = ``new` `ArrayList();` `        ``int` `current = ``1``;` `        ``int` `i = ``1``;`   `        ``// while current perfect cube is` `        ``// less than or equal to n` `        ``while` `(current <= n) {` `            ``perfectcubes.add(current);` `            ``i += ``1``;` `            ``current = (``int``) (Math.pow(i, ``3``));` `        ``}` `        ``return` `perfectcubes;` `    ``}`   `    ``// Function to print the sum of maximum` `    ``// two elements from the array` `    ``static` `int` `maxPairSum(``int``[] arr) {`   `        ``int` `n = arr.length;` `        ``int` `max = ``0``;` `        ``int` `secondMax = ``0``;` `        ``if` `(arr[``0``] > arr[``1``]) {` `            ``max = arr[``0``];` `            ``secondMax = arr[``1``];` `        ``} ``else` `{` `            ``max = arr[``1``];` `            ``secondMax = arr[``0``];` `        ``}` `        ``for` `(``int` `i = ``2``; i < n; i++) {` `            ``if` `(arr[i] > max) {` `                ``secondMax = max;` `                ``max = arr[i];` `            ``} ``else` `if` `(arr[i] > secondMax) {` `                ``secondMax = arr[i];` `            ``}` `        ``}` `        ``return` `(max + secondMax);` `    ``}`   `    ``// Function to return the count of numbers that` `    ``// when added with n give a perfect cube` `    ``static` `int` `countPairsWith(``int` `n, List ` `            ``perfectcubes, List nums) {`   `        ``int` `count = ``0``;` `        ``for` `(``int` `i = ``0``; i < perfectcubes.size(); i++) {` `            ``int` `temp = perfectcubes.get(i) - n;`   `            ``// temp > n is checked so that pairs` `            ``// (x, y) and (y, x) don't get counted twice` `            ``if` `(temp > n && (nums.contains(temp)))` `                ``count += ``1``;` `        ``}` `        ``return` `count;` `    ``}`   `    ``// Function to count the pairs whose` `    ``// sum is a perfect cube` `    ``static` `int` `countPairs(``int``[] arr) {`   `        ``int` `n = arr.length;`   `        ``// Sum of the maximum two elements` `        ``// from the array` `        ``int` `max = maxPairSum(arr);`   `        ``// List of perfect cubes upto max` `        ``List perfectcubes = getPerfectcubes(max);`   `        ``// Contains all the array elements` `        ``List nums = ``new` `ArrayList();` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``nums.add(arr[i]);` `        ``}` `        ``int` `count = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++) {`   `            ``// Add count of the elements that when` `            ``// added with arr[i] give a perfect cube` `            ``count += countPairsWith(arr[i], perfectcubes, nums);` `        ``}` `        ``return` `count;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] agrs) {` `        ``int``[] arr = { ``2``, ``6``, ``18``, ``9``, ``999``, ``1` `};` `        ``System.out.print(countPairs(arr));` `    ``}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the approach `   `# Function to return an ArrayList containing ` `# all the perfect cubes upto n ` `def` `getPerfectcubes(n): `   `    ``perfectcubes ``=` `[]; ` `    ``current ``=` `1``; ` `    ``i ``=` `1``; `   `    ``# while current perfect cube is ` `    ``# less than or equal to n ` `    ``while` `(current <``=` `n): ` `        ``perfectcubes.append(current); ` `        ``i ``+``=` `1``; ` `        ``current ``=` `int``(``pow``(i, ``3``)); `   `    ``return` `perfectcubes; `   `# Function to print the sum of maximum ` `# two elements from the array ` `def` `maxPairSum(arr): `   `    ``n ``=` `len``(arr); ` `    ``max` `=` `0``; ` `    ``secondMax ``=` `0``; ` `    ``if` `(arr[``0``] > arr[``1``]): ` `        ``max` `=` `arr[``0``]; ` `        ``secondMax ``=` `arr[``1``]; ` `    ``else``: ` `        ``max` `=` `arr[``1``]; ` `        ``secondMax ``=` `arr[``0``]; `   `    ``for` `i ``in` `range``(``2``, n): ` `        ``if` `(arr[i] > ``max``): ` `            ``secondMax ``=` `max``; ` `            ``max` `=` `arr[i]; ` `        ``elif` `(arr[i] > secondMax): ` `            ``secondMax ``=` `arr[i]; `   `    ``return` `(``max` `+` `secondMax); `   `# Function to return the count of numbers that ` `# when added with n give a perfect cube ` `def` `countPairsWith(n, perfectcubes, nums): `   `    ``count ``=` `0``; ` `    ``for` `i ``in` `range``(``len``(perfectcubes)): ` `        ``temp ``=` `perfectcubes[i] ``-` `n; `   `        ``# temp > n is checked so that pairs ` `        ``# (x, y) and (y, x) don't get counted twice ` `        ``if` `(temp > n ``and` `(temp ``in` `nums)): ` `            ``count ``+``=` `1``; `   `    ``return` `count; `   `# Function to count the pairs whose ` `# sum is a perfect cube ` `def` `countPairs(arr): `   `    ``n ``=` `len``(arr); `   `    ``# Sum of the maximum two elements ` `    ``# from the array ` `    ``max` `=` `maxPairSum(arr); `   `    ``# List of perfect cubes upto max ` `    ``perfectcubes ``=` `getPerfectcubes(``max``); `   `    ``# Contains all the array elements ` `    ``nums ``=` `[]; ` `    ``for` `i ``in` `range``(n): ` `        ``nums.append(arr[i]); `   `    ``count ``=` `0``; ` `    ``for` `i ``in` `range``(n): `   `        ``# Add count of the elements that when ` `        ``# added with arr[i] give a perfect cube ` `        ``count ``+``=` `countPairsWith(arr[i], ` `                ``perfectcubes, nums); ` `    ``return` `count; `   `# Driver code ` `arr ``=` `[ ``2``, ``6``, ``18``, ``9``, ``999``, ``1` `]; ` `print``(countPairs(arr)); `

## C#

 `// C# implementation of the approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG ` `{` ` `  `    ``// Function to return an List containing` `    ``// all the perfect cubes upto n` `    ``static` `List<``int``> getPerfectcubes(``int` `n) {` ` `  `        ``List<``int``> perfectcubes = ``new` `List<``int``>();` `        ``int` `current = 1;` `        ``int` `i = 1;` ` `  `        ``// while current perfect cube is` `        ``// less than or equal to n` `        ``while` `(current <= n) {` `            ``perfectcubes.Add(current);` `            ``i += 1;` `            ``current = (``int``) (Math.Pow(i, 3));` `        ``}` `        ``return` `perfectcubes;` `    ``}` ` `  `    ``// Function to print the sum of maximum` `    ``// two elements from the array` `    ``static` `int` `maxPairSum(``int``[] arr) {` ` `  `        ``int` `n = arr.Length;` `        ``int` `max = 0;` `        ``int` `secondMax = 0;` `        ``if` `(arr[0] > arr[1]) {` `            ``max = arr[0];` `            ``secondMax = arr[1];` `        ``} ``else` `{` `            ``max = arr[1];` `            ``secondMax = arr[0];` `        ``}` `        ``for` `(``int` `i = 2; i < n; i++) {` `            ``if` `(arr[i] > max) {` `                ``secondMax = max;` `                ``max = arr[i];` `            ``} ``else` `if` `(arr[i] > secondMax) {` `                ``secondMax = arr[i];` `            ``}` `        ``}` `        ``return` `(max + secondMax);` `    ``}` ` `  `    ``// Function to return the count of numbers that` `    ``// when added with n give a perfect cube` `    ``static` `int` `countPairsWith(``int` `n, List<``int``> ` `            ``perfectcubes, List<``int``> nums) {` ` `  `        ``int` `count = 0;` `        ``for` `(``int` `i = 0; i < perfectcubes.Count; i++) {` `            ``int` `temp = perfectcubes[i] - n;` ` `  `            ``// temp > n is checked so that pairs` `            ``// (x, y) and (y, x) don't get counted twice` `            ``if` `(temp > n && (nums.Contains(temp)))` `                ``count += 1;` `        ``}` `        ``return` `count;` `    ``}` ` `  `    ``// Function to count the pairs whose` `    ``// sum is a perfect cube` `    ``static` `int` `countPairs(``int``[] arr) {` ` `  `        ``int` `n = arr.Length;` ` `  `        ``// Sum of the maximum two elements` `        ``// from the array` `        ``int` `max = maxPairSum(arr);` ` `  `        ``// List of perfect cubes upto max` `        ``List<``int``> perfectcubes = getPerfectcubes(max);` ` `  `        ``// Contains all the array elements` `        ``List<``int``> nums = ``new` `List<``int``>();` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``nums.Add(arr[i]);` `        ``}` `        ``int` `count = 0;` `        ``for` `(``int` `i = 0; i < n; i++) {` ` `  `            ``// Add count of the elements that when` `            ``// added with arr[i] give a perfect cube` `            ``count += countPairsWith(arr[i], perfectcubes, nums);` `        ``}` `        ``return` `count;` `    ``}` ` `  `    ``// Driver code` `    ``public` `static` `void` `Main(String[] agrs) {` `        ``int``[] arr = { 2, 6, 18, 9, 999, 1 };` `        ``Console.Write(countPairs(arr));` `    ``}` `}`   `// This code contributed by Rajput-Ji`

## Javascript

 ``

Output:

`3`

Time Complexity: O(n3)

Auxiliary Space: O(n)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!