GeeksforGeeks App
Open App
Browser
Continue

# Check if a number can be represented as product of two positive perfect cubes

Given a positive integer N, the task is to check if the given number N can be represented as the product of two positive perfect cubes or not. If it is possible, then print “Yes”. Otherwise, print “No”.

Examples:

Input: N = 216
Output: Yes
Explanation:
The given number N(= 216) can be represented as 8 * 27 =  23 * 33.
Therefore, print Yes.

Input: N = 10
Output: No

Approach: The simplest approach to solve the given problem is to store the perfect cubes of all numbers from 1 to cubic root of N in a Map and check if N can be represented as the product of two numbers present in the Map or not

Follow the steps below to solve the problem:

• Initialize an ordered map, say cubes, that stores the perfect cubes in sorted order.
• Traverse the map and check if there exists any pair whose product is N, then print “Yes”. Otherwise, print “No”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to check if N can``// be represented as the product``// of two perfect cubes or not``void` `productOfTwoPerfectCubes(``int` `N)``{``    ``// Stores the perfect cubes``    ``map<``int``, ``int``> cubes;` `    ``for` `(``int` `i = 1;``         ``i * i * i <= N; i++)``        ``cubes[i * i * i] = i;` `    ``// Traverse the Map``    ``for` `(``auto` `itr = cubes.begin();``         ``itr != cubes.end();``         ``itr++) {` `        ``// Stores the first number``        ``int` `firstNumber = itr->first;` `        ``if` `(N % itr->first == 0) {` `            ``// Stores the second number``            ``int` `secondNumber = N / itr->first;` `            ``// Search the pair for the``            ``// first number to obtain``            ``// product N from the Map``            ``if` `(cubes.find(secondNumber)``                ``!= cubes.end()) {``                ``cout << ``"Yes"``;``                ``return``;``            ``}``        ``}``    ``}` `    ``// If N cannot be represented``    ``// as the product of the two``    ``// positive perfect cubes``    ``cout << ``"No"``;``}` `// Driver Code``int` `main()``{``    ``int` `N = 216;``    ``productOfTwoPerfectCubes(N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{``    ` `// Function to check if N can``// be represented as the product``// of two perfect cubes or not``static` `void` `productOfTwoPerfectCubes(``int` `N)``{``    ` `    ``// Stores the perfect cubes``    ``Map cubes = ``new` `HashMap<>();` `    ``for``(``int` `i = ``1``; i * i * i <= N; i++)``        ``cubes.put(i * i * i,i);` `    ``// Traverse the Map``    ``for``(Map.Entry itr: cubes.entrySet())``    ``{``        ` `        ``// Stores the first number``        ``int` `firstNumber = itr.getKey();` `        ``if` `(N % itr.getKey() == ``0``)``        ``{``            ` `            ``// Stores the second number``            ``int` `secondNumber = N / itr.getKey();` `            ``// Search the pair for the``            ``// first number to obtain``            ``// product N from the Map``            ``if` `(cubes.containsKey(secondNumber))``            ``{``                ``System.out.println(``"Yes"``);``                ``return``;``            ``}``        ``}``    ``}` `    ``// If N cannot be represented``    ``// as the product of the two``    ``// positive perfect cubes``    ``System.out.println(``"No"``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``216``;``    ` `    ``productOfTwoPerfectCubes(N);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program for the above approach` `# Function to check if N can``# be represented as the product``# of two perfect cubes or not``def` `productOfTwoPerfectCubes(N):` `    ``# Stores the perfect cubes``    ``cubes ``=` `{}` `    ``i ``=` `1``    ` `    ``while` `i ``*` `i ``*` `i <``=` `N:``        ``cubes[i ``*` `i ``*` `i] ``=` `i``        ``i ``+``=` `1` `    ``# Traverse the Map``    ``for` `itr ``in` `cubes:` `        ``# Stores the first number``        ``firstNumber ``=` `itr` `        ``if` `(N ``%` `itr ``=``=` `0``):` `            ``# Stores the second number``            ``secondNumber ``=` `N ``/``/` `itr` `            ``# Search the pair for the``            ``# first number to obtain``            ``# product N from the Map``            ``if` `(secondNumber ``in` `cubes):``                ``print``(``"Yes"``)``                ``return` `    ``# If N cannot be represented``    ``# as the product of the two``    ``# positive perfect cubes``    ``print``(``"No"``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``N ``=` `216``    ` `    ``productOfTwoPerfectCubes(N)` `# This code is contributed by mohit ukasp`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{`` ` ` ``// Function to check if N can``// be represented as the product``// of two perfect cubes or not``static` `void` `productOfTwoPerfectCubes(``int` `N)``{``    ``// Stores the perfect cubes``    ``Dictionary<``int``,``int``> cubes = ``new` `Dictionary<``int``,``int``>();` `    ``for` `(``int` `i = 1; i * i * i <= N; i++){``       ``cubes.Add(i * i * i, i);``    ``}` `    ``// Traverse the Map``    ``foreach``(KeyValuePair<``int``, ``int``> kvp ``in` `cubes)``   ``{` `        ``// Stores the first number``        ``int` `firstNumber = kvp.Key;` `        ``if` `(N % kvp.Key == 0) {` `            ``// Stores the second number``            ``int` `secondNumber = N / kvp.Key;` `            ``// Search the pair for the``            ``// first number to obtain``            ``// product N from the Map``            ``if` `(cubes.ContainsKey(secondNumber)) {``                ``Console.Write(``"Yes"``);``                ``return``;``            ``}``        ``}``    ``}` `    ``// If N cannot be represented``    ``// as the product of the two``    ``// positive perfect cubes``    ``Console.Write(``"No"``);``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `N = 216;``    ``productOfTwoPerfectCubes(N);` `}``}` `// This code is contributed by ipg2016107..`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(N1/3 * log(N))
Auxiliary Space: O(N1/3)

Efficient Approach: The above approach can also be optimized based on the observation that only perfect cubes can be represented as a product of 2 perfect cubes.

Let the two numbers be x and y such that x3 * y3= N — (1)
Equation (1) can be written as:
=> (x*y)3 = N
Taking cube root both sides,
=> x*y = (N)1/3 — (2)
For equation (2) to be true, N should be a perfect cube.

So, the problem is reduced to check if N is a perfect cube or not. If found to be true, print “Yes”, else “No”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to check if the number N``// can be represented as the product``// of two perfect cubes or not``void` `productOfTwoPerfectCubes(``int` `N)``{``    ``int` `cube_root;``    ``cube_root = round(cbrt(N));` `    ``// If cube of cube_root is N``    ``if` `(cube_root * cube_root``            ``* cube_root``        ``== N) {` `        ``cout << ``"Yes"``;``        ``return``;``    ``}` `    ``// Otherwise, print No``    ``else` `{``        ``cout << ``"No"``;``        ``return``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 216;``    ``productOfTwoPerfectCubes(N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.lang.*;` `class` `GFG{``    ` `// Function to check if the number N``// can be represented as the product``// of two perfect cubes or not``public` `static` `void` `productOfTwoPerfectCubes(``double` `N)``{``    ``double` `cube_root;``    ``cube_root = Math.round(Math.cbrt(N));` `    ``// If cube of cube_root is N``    ``if` `(cube_root * cube_root * cube_root == N)``    ``{``        ``System.out.println(``"Yes"``);``        ``return``;``    ``}` `    ``// Otherwise, print No``    ``else``    ``{``        ``System.out.println(``"No"``);``        ``return``;``    ``}``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``double` `N = ``216``;``    ` `    ``productOfTwoPerfectCubes(N);``}``}` `// This code is contributed by SoumikMondal`

## Python3

 `# Python3 program for the above approach` `# Function to check if the number N``# can be represented as the product``# of two perfect cubes or not``def` `productOfTwoPerfectCubes(N):``    ` `    ``cube_root ``=` `round``((N) ``*``*` `(``1` `/` `3``))``    ``print``(cube_root)` `    ``# If cube of cube_root is N``    ``if` `(cube_root ``*` `cube_root ``*` `cube_root ``=``=` `N):``        ``print``(``"Yes"``)``        ``return``    ` `    ``# Otherwise, print No``    ``else``:``        ``print``(``"No"``)``        ``return` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``N ``=` `216``    ` `    ``productOfTwoPerfectCubes(N)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``using` `System.Linq;` `class` `GFG{``    ` `// Function to check if the number N``// can be represented as the product``// of two perfect cubes or not``public` `static` `void` `productOfTwoPerfectCubes(``double` `N)``{``    ``double` `cube_root;``    ``cube_root = Math.Round(Math.Cbrt(N));` `    ``// If cube of cube_root is N``    ``if` `(cube_root * cube_root * cube_root == N)``    ``{``        ``Console.Write(``"Yes"``);``        ``return``;``    ``}` `    ``// Otherwise, print No``    ``else``    ``{``        ``Console.Write(``"No"``);``        ``return``;``    ``}``}` `// Driver Code``static` `public` `void` `Main()``{``    ``double` `N = 216;``    ` `    ``productOfTwoPerfectCubes(N);``}``}` `// This code is contributed by mohit kumar 29.`

## Javascript

 ``

Output:

`Yes`

Time Complexity: O(N1/3)
Auxiliary Space: O(1)

### Approach 3: Brute Force Approach:

The above implementation checks all possible pairs of perfect cubes (up to the cube root of N) to see if their product is equal to N. If a pair is found, then N can be expressed as the product of two perfect cubes. Otherwise, N cannot be expressed as the product of two perfect cubes. The time complexity of this implementation is O(N^(1/3)*N^(1/3)) = O(N^(2/3)), and the space complexity is O(1). This approach is not very efficient for large values of N because it performs a large number of checks, but it is simple and easy to implement.

Here is the code for above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to check if the number N``// can be represented as the product``// of two perfect cubes or not``void` `productOfTwoPerfectCubes(``int` `N)``{``    ``// Check all possible pairs of perfect cubes``    ``for``(``int` `i=1;i<=cbrt(N);i++){``        ``for``(``int` `j=1;j<=cbrt(N);j++){``            ``int` `val = i*i*i*j*j*j;``            ``if``(val == N){``                ``cout<<``"Yes"``;``                ``return``;``            ``}``        ``}``    ``}``    ` `    ``// If no such pair exists, print No``    ``cout<<``"No"``;``}` `// Driver Code``int` `main()``{``    ``int` `N = 216;``    ``productOfTwoPerfectCubes(N);``    ``return` `0;``}`

## Java

 `import` `java.util.*;` `public` `class` `Main {``// Function to check if the number N``// can be represented as the product``// of two perfect cubes or not``static` `void` `productOfTwoPerfectCubes(``int` `N) {``    ``// Check all possible pairs of perfect cubes``    ``for` `(``int` `i = ``1``; i <= Math.cbrt(N); i++) {``        ``for` `(``int` `j = ``1``; j <= Math.cbrt(N); j++) {``            ``int` `val = i * i * i * j * j * j;``            ``if` `(val == N) {``                ``System.out.println(``"Yes"``);``                ``return``;``            ``}``        ``}``    ``}``    ``// If no such pair exists, print No``    ``System.out.println(``"No"``);``}` `// Driver Code``public` `static` `void` `main(String[] args) {``    ``int` `N = ``216``;``    ``productOfTwoPerfectCubes(N);``}``}`

Output

`Yes`

Time Complexity: O(N1/3 * log(N))
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up