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

Last Updated : 23 Jul, 2025

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 = 2³* 3³.
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 <bits/stdc++.h>
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<Integer, Integer> cubes = new HashMap<>();

    for(int i = 1; i * i * i <= N; i++)
        cubes.put(i * i * i,i);

    // Traverse the Map
    for(Map.Entry<Integer, 
                  Integer> 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# 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

<script>

// Javascript program for the above approach

// Function to check if N can
// be represented as the product
// of two perfect cubes or not
function productOfTwoPerfectCubes(N)
{
    
    // Stores the perfect cubes
    let cubes = new Map();
 
    for(let i = 1; i * i * i <= N; i++)
        cubes.set(i * i * i, i);
 
    // Traverse the Map
    for(let [key, value] of cubes.entries())
    {
        
        // Stores the first number
        let firstNumber = key;
 
        if (N % key == 0)
        {
             
            // Stores the second number
            let secondNumber = N / key;
 
            // Search the pair for the
            // first number to obtain
            // product N from the Map
            if (cubes.has(secondNumber))
            {
                document.write("Yes<br>");
                return;
            }
        }
    }
 
    // If N cannot be represented
    // as the product of the two
    // positive perfect cubes
    document.write("No<br>");
}

// Driver code
let N = 216;
     
productOfTwoPerfectCubes(N);

// This code is contributed by avanitrachhadiya2155

</script>

Output

Yes

Time Complexity: O(N^1/3 * log(N))
Auxiliary Space: O(N^1/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 x³* y³= N — (1)
Equation (1) can be written as:
=> (x*y)³ = 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 <bits/stdc++.h>
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# 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

<script>

// Javascript program for the above approach

// Function to check if the number N
// can be represented as the product
// of two perfect cubes or not
function productOfTwoPerfectCubes(N)
{
    var cube_root;
    cube_root = Math.round(Math.cbrt(N));

    // If cube of cube_root is N
    if (cube_root * cube_root * cube_root == N)
    {
        document.write("Yes");
        return;
    }

    // Otherwise, print No
    else 
    {
        document.write("No");
        return;
    }
}

// Driver code
var N = 216;
productOfTwoPerfectCubes(N);

// This code is contributed by Ankita saini

</script>

Output

Yes

Time Complexity: O(N^1/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 <bits/stdc++.h>
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);
}
}

Python3

# Function to check if the number N
# can be represented as the product
# of two perfect cubes or not
def productOfTwoPerfectCubes(N):
    # Check all possible pairs of perfect cubes
    for i in range(1, int(N ** (1/3)) + 1):
        for j in range(1, int(N ** (1/3)) + 1):
            val = i ** 3 * j ** 3
            if val == N:
                print("Yes")
                return
    
    # If no such pair exists, print No
    print("No")

# Driver Code
N = 216
productOfTwoPerfectCubes(N)

# This code is contributed by shivamgupta310570

using System;

class Program
{
    // 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.Ceiling(Math.Pow(N, 1.0 / 3)); i++)
        {
            for (int j = 1; j <= Math.Ceiling(Math.Pow(N, 1.0 / 3)); j++)
            {
                int val = i * i * i * j * j * j;
                if (val == N)
                {
                    Console.WriteLine("Yes");
                    return;
                }
            }
        }

        // If no such pair exists, print No
        Console.WriteLine("No");
    }

    // Driver Code
    static void Main()
    {
        int N = 216;
        ProductOfTwoPerfectCubes(N);
    }
}

JavaScript

// Function to check if the number N
// can be represented as the product
// of two perfect cubes or not
function productOfTwoPerfectCubes(N) {
    // Check all possible pairs of perfect cubes
    for (let i = 1; i <= Math.cbrt(N); i++) {
        for (let j = 1; j <= Math.cbrt(N); j++) {
            let val = i * i * i * j * j * j;
            if (val === N) {
                console.log("Yes");
                return;
            }
        }
    }
    // If no such pair exists, print No
    console.log("No");
}
// Driver Code
let N = 216;
productOfTwoPerfectCubes(N);

Output

Yes

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

babayaga18

Improve

Article Tags :

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

Approach 3: Brute Force Approach:

Explore

DSA Fundamentals

Data Structures

Algorithms

Advanced

Interview Preparation

Practice Problem

Thank You!

What kind of Experience do you want to share?