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 =  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#

// 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#

// 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);
}
}

Output

Yes

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