Open In App
Related Articles

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

Given an integer N, the task is to check if N can be represented as the sum of two positive perfect cubes or not.

Examples:

Input: N = 28
Output: Yes
Explanation: 
Since, 28 = 27 + 1 = 33 + 13.
Therefore, the required answer is Yes

Input: N = 34
Output: No

 

Approach: The idea 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 sum of two numbers present in the Map or not. Follow the steps below to solve the problem:

  1. Initialize an ordered map, say cubes, to store the perfect cubes of first N natural numbers in sorted order.
  2. Traverse the map and check for the pair having a sum equal to N.
  3. If such a pair is found having sum 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 sum of two perfect cubes or not
void sumOfTwoPerfectCubes(int N)
{
    // Stores the perfect cubes
    // of first N natural numbers
    map<int, int> cubes;
    for (int i = 1; i * i * i <= N; i++)
        cubes[i * i * i] = i;
 
    // Traverse the map
    map<int, int>::iterator itr;
    for (itr = cubes.begin();
         itr != cubes.end(); itr++) {
 
        // Stores first number
        int firstNumber = itr->first;
 
        // Stores second number
        int secondNumber = N - itr->first;
 
        // Search the pair for the first
        // number to obtain sum N from the Map
        if (cubes.find(secondNumber)
            != cubes.end()) {
            cout << "True";
            return;
        }
    }
 
    // If N cannot be represented as
    // sum of two positive perfect cubes
    cout << "False";
}
 
// Driver Code
int main()
{
    int N = 28;
 
    // Function call to check if N
    // can be represented as
    // sum of two perfect cubes or not
    sumOfTwoPerfectCubes(N);
 
    return 0;
}

                    

Java

// Java program for the above approach
import java.util.*;
class GFG
{
 
  // Function to check if N can be represented
  // as sum of two perfect cubes or not
  public static void sumOfTwoPerfectCubes(int N)
  {
 
    // Stores the perfect cubes
    // of first N natural numbers
    HashMap<Integer, Integer> cubes = new HashMap<>();
    for (int i = 1; i * i * i <= N; i++)
      cubes.put((i * i * i), i);
 
    // Traverse the map
    Iterator<Map.Entry<Integer, Integer> > itr
      = cubes.entrySet().iterator();
    while (itr.hasNext())
    {
      Map.Entry<Integer, Integer> entry = itr.next();
 
      // Stores first number
      int firstNumber = entry.getKey();
 
      // Stores second number
      int secondNumber = N - entry.getKey();
 
      // Search the pair for the first
      // number to obtain sum N from the Map
      if (cubes.containsKey(secondNumber))
      {
        System.out.println("True");
        return;
      }
    }
 
    // If N cannot be represented as
    // sum of two positive perfect cubes
    System.out.println("False");
  }
 
  // Driver code
  public static void main(String[] args)
  {
    int N = 28;
 
    // Function call to check if N
    // can be represented as
    // sum of two perfect cubes or not
    sumOfTwoPerfectCubes(N);
  }
}
 
// This code is contributed by shailjapriya.

                    

Python3

# Python3 program for the above approach
 
# Function to check if N can be represented
# as sum of two perfect cubes or not
def sumOfTwoPerfectCubes(N) :
 
    # Stores the perfect cubes
    # of first N natural numbers
    cubes = {}
    i = 1
    while i*i*i <= N :
        cubes[i*i*i] = i
        i += 1
  
    # Traverse the map
    for itr in cubes :
  
        # Stores first number
        firstNumber = itr
  
        # Stores second number
        secondNumber = N - itr
  
        # Search the pair for the first
        # number to obtain sum N from the Map
        if secondNumber in cubes :
            print("True", end = "")
            return
  
    # If N cannot be represented as
    # sum of two positive perfect cubes
    print("False", end = "")
 
N = 28
 
# Function call to check if N
# can be represented as
# sum of two perfect cubes or not
sumOfTwoPerfectCubes(N)
 
# This code is contributed by divyeshrabadiya07.

                    

Javascript

<script>
 
// Javascript program for the above approach
 
// Function to check if N can be represented
// as sum of two perfect cubes or not
function sumOfTwoPerfectCubes(N)
{
    // Stores the perfect cubes
    // of first N natural numbers
    var cubes = new Map();
    for (var i = 1; i * i * i <= N; i++)
        cubes.set(i * i * i, i);
 
    var ans = false;
    // Traverse the map
    cubes.forEach((value, key) => {
        // Stores first number
        var firstNumber = key;
 
        // Stores second number
        var secondNumber = N - value;
 
        // Search the pair for the first
        // number to obtain sum N from the Map
        if (cubes.has(secondNumber)) {
            document.write( "True");
            ans = true;
            return;
        }
    });
   
    if(ans)
    {
        return;
    }
    // If N cannot be represented as
    // sum of two positive perfect cubes
    document.write( "False");
}
 
// Driver Code
var N = 28;
// Function call to check if N
// can be represented as
// sum of two perfect cubes or not
sumOfTwoPerfectCubes(N);
 
 
</script>

                    

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
using System.Linq;
 
class GFG{
 
  // Function to check if N can be represented
  // as sum of two perfect cubes or not
  public static void sumOfTwoPerfectCubes(int N)
  {
 
    // Stores the perfect cubes
    // of first N natural numbers
    Dictionary<int,
             int> cubes = new Dictionary<int,
                                      int>();
    for (int i = 1; i * i * i <= N; i++)
      cubes.Add((i * i * i), i);
     
    var val = cubes.Keys.ToList();
    foreach(var key in val)
    {
      // Stores first number
      int firstNumber = cubes[1];
 
      // Stores second number
      int secondNumber = N - cubes[1];
 
      // Search the pair for the first
      // number to obtain sum N from the Map
      if (cubes.ContainsKey(secondNumber))
      {
        Console.Write("True");
        return;
      }
    }
 
    // If N cannot be represented as
    // sum of two positive perfect cubes
    Console.Write("False");
  }
 
 
// Driver Code
static public void Main()
{
    int N = 28;
 
    // Function call to check if N
    // can be represented as
    // sum of two perfect cubes or not
    sumOfTwoPerfectCubes(N);
}
}
 
// This code is contributed by code_hunt.

                    

Output
True

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

Approach 2: Using two Pointers

We will declare lo to 1 and hi to cube root of n(the given number), then by (lo<=hi) this condition, if current is smaller than n we will increment the lo and in another hand if it is greater then decrement the hi, where current is (lo*lo*lo + hi*hi*hi)

C++

// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if N can be represented
// as sum of two perfect cubes or not
bool sumOfTwoCubes(int n)
{
    long long int lo = 1, hi = (long long int)cbrt(n);
    while (lo <= hi) {
        long long int curr = (lo * lo * lo + hi * hi * hi);
        if (curr == n)
            // if it is same return true;
            return true;
        if (curr < n)
            // if the curr smaller than n increment the lo
            lo++;
        else
            // if the curr is greater than curr decrement
            // the hi
            hi--;
    }
    return false;
}
 
// Driver Code
int main()
{
    int N = 28;
 
    // Function call to check if N
    // can be represented as
    // sum of two perfect cubes or not
    if (sumOfTwoCubes(N)) {
        cout << "True";
    }
    else {
        cout << "False";
    }
 
    return 0;
}

                    

Java

// Java program for the above approach
import java.io.*;
 
class GFG
{
 
// Function to check if N can be represented
// as sum of two perfect cubes or not
static boolean sumOfTwoCubes(int n)
{
    int lo = 1, hi = (int)Math.cbrt(n);
    while (lo <= hi) {
        int curr = (lo * lo * lo + hi * hi * hi);
        if (curr == n)
           
            // if it is same return true;
            return true;
        if (curr < n)
           
            // if the curr smaller than n increment the lo
            lo++;
        else
           
            // if the curr is greater than curr decrement
            // the hi
            hi--;
    }
    return false;
}
 
// Driver Code
public static void main (String[] args)
{
    int N = 28;
 
    // Function call to check if N
    // can be represented as
    // sum of two perfect cubes or not
    if (sumOfTwoCubes(N)) {
        System.out.println("True");
    }
    else {
        System.out.println("False");
    }
 
}
}
 
// This code is contributed by shivanisinghss2110

                    

Python3

# Python3 program for the above approach
import math
 
# Function to check if N can be represented
# as sum of two perfect cubes or not
def sumOfTwoCubes(n):
 
    lo = 1
    hi = round(math.pow(n, 1 / 3))
     
    while (lo <= hi):
        curr = (lo * lo * lo + hi * hi * hi)
        if (curr == n):
             
            # If it is same return true;
            return True
        if (curr < n):
             
            # If the curr smaller than n increment the lo
            lo += 1
        else:
             
            # If the curr is greater than curr decrement
            # the hi
            hi -= 1
     
    return False
 
# Driver Code
N = 28
 
# Function call to check if N
# can be represented as sum of
# two perfect cubes or not
if (sumOfTwoCubes(N)):
    print("True")
else:
    print("False")
     
# This code is contributed by shivanisinghss2110

                    

Javascript

<script>
// JavaScript program for the above approach
// Function to check if N can be represented
// as sum of two perfect cubes or not
function sumOfTwoCubes(n)
{
    var lo = 1, hi = (n);
    while (lo <= hi) {
        var curr = (lo * lo * lo + hi * hi * hi);
        if (curr == n)
         
            // if it is same return true;
            return true;
        if (curr < n)
         
            // if the curr smaller than n increment the lo
            lo++;
        else
         
            // if the curr is greater than curr decrement
            // the hi
            hi--;
    }
    return false;
}
 
// Driver Code
    var N = 28;
 
    // Function call to check if N
    // can be represented as
    // sum of two perfect cubes or not
    if (sumOfTwoCubes(N)) {
        document.write("True");
    }
    else {
        document.write("False");
    }
 
// This code is contributed by shivanisinghss2110
</script>

                    

C#

// C# program for the above approach
using System;
 
class GFG
{
 
// Function to check if N can be represented
// as sum of two perfect cubes or not
static bool sumOfTwoCubes(int n)
{
    int lo = 1, hi = (int)Math.Pow(n, (1.0 / 3.0));
    while (lo <= hi) {
        int curr = (lo * lo * lo + hi * hi * hi);
        if (curr == n)
           
            // if it is same return true;
            return true;
        if (curr < n)
           
            // if the curr smaller than n increment the lo
            lo++;
        else
           
            // if the curr is greater than curr decrement
            // the hi
            hi--;
    }
    return false;
}
 
// Driver Code
public static void Main (String[] args)
{
    int N = 28;
 
    // Function call to check if N
    // can be represented as
    // sum of two perfect cubes or not
    if (sumOfTwoCubes(N)) {
        Console.Write("True");
    }
    else {
        Console.Write("False");
    }
 
}
}
 
// This code is contributed by shivanisinghss2110

                    

Output
True

Time Complexity : O(log(cbrt(n))),where n is given number 

Auxiliary Space: O(1)

Approach 3: Dynamic Programming

Here’s the Dynamic Programming (DP) approach to solve the problem of finding whether a given number N can be represented as the sum of two perfect cubes or not:

We can create a DP array dp[N+1], where dp[i] is set to 1 if the number i can be represented as the sum of two perfect cubes, and 0 otherwise. We can initialize dp[0] as 1 (since 0 can be represented as the sum of two 0’s), and dp[i] as 0 for all i > 0.

Then, we can iterate over all possible pairs of perfect cubes (i^3 + j^3) such that i^3 + j^3 <= N, and mark dp[i^3 + j^3] as 1. This can be done using two nested loops:

Here is the code below:

C++

#include <bits/stdc++.h>
using namespace std;
 
// Function to check if N can be represented
// as sum of two perfect cubes or not
bool sumOfTwoPerfectCubes(int N)
{
  // DP array to store whether a number can be represented as the sum of two perfect cubes
  vector<int> dp(N+1, 0);
   
  // Base case: 0 can be represented as the sum of two 0's
  dp[0] = 1;
   
  // Mark all numbers that can be represented as the sum of two perfect cubes
  for (int i = 1; i * i * i <= N; i++) {
    for (int j = 1; j * j * j <= N - i * i * i; j++) {
      int sum = i * i * i + j * j * j;
      if (sum <= N) dp[sum] = 1;
    }
  }
   
  // Return true if N can be represented as the sum of two perfect cubes, false otherwise
  return dp[N];
}
 
// Driver Code
int main()
{
  int N = 28;
 
  // Function call to check if N
  // can be represented as
  // sum of two perfect cubes or not
  if (sumOfTwoPerfectCubes(N)) {
    cout << "True";
  } else {
    cout << "False";
  }
 
  return 0;
}

                    

Java

import java.util.*;
 
public class Main {
    // Function to check if N can be represented
    // as sum of two perfect cubes or not
    public static boolean sumOfTwoPerfectCubes(int N)
    {
        // DP array to store whether a number can be
        // represented as the sum of two perfect cubes
        int[] dp = new int[N + 1];
 
        // Base case: 0 can be represented as the sum of two
        // 0's
        dp[0] = 1;
 
        // Mark all numbers that can be represented as the
        // sum of two perfect cubes
        for (int i = 1; i * i * i <= N; i++) {
            for (int j = 1; j * j * j <= N - i * i * i;
                 j++) {
                int sum = i * i * i + j * j * j;
                if (sum <= N)
                    dp[sum] = 1;
            }
        }
 
        // Return true if N can be represented as the sum of
        // two perfect cubes, false otherwise
        return dp[N] == 1;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int N = 28;
 
        // Function call to check if N
        // can be represented as
        // sum of two perfect cubes or not
        if (sumOfTwoPerfectCubes(N)) {
            System.out.println("True");
        }
        else {
            System.out.println("False");
        }
    }
}

                    

Python3

# Function to check if N can be represented
# as sum of two perfect cubes or not
def sumOfTwoPerfectCubes(N):
    # DP array to store whether a number can be represented as the sum of two perfect cubes
    dp = [0] * (N + 1)
     
    # Base case: 0 can be represented as the sum of two 0's
    dp[0] = 1
     
    # Mark all numbers that can be represented as the sum of two perfect cubes
    for i in range(1, int(N ** (1/3)) + 1):
        for j in range(1, int((N - i**3) ** (1/3)) + 1):
            sum = i**3 + j**3
            if sum <= N:
                dp[sum] = 1
     
    # Return true if N can be represented as the sum of two perfect cubes, false otherwise
    return dp[N]
 
# Driver code
N = 28
 
# Function call to check if N
# can be represented as
# sum of two perfect cubes or not
if sumOfTwoPerfectCubes(N):
    print("True")
else:
    print("False")

                    

C#

using System;
 
public class Program {
    // Function to check if N can be represented
    // as sum of two perfect cubes or not
    public static bool SumOfTwoPerfectCubes(int N)
    {
        // DP array to store whether a number can be
        // represented as the sum of two perfect cubes
        int[] dp = new int[N + 1];
 
        // Base case: 0 can be represented as the sum of two
        // 0's
        dp[0] = 1;
 
        // Mark all numbers that can be represented as the
        // sum of two perfect cubes
        for (int i = 1; i * i * i <= N; i++) {
            for (int j = 1; j * j * j <= N - i * i * i;
                 j++) {
                int sum = i * i * i + j * j * j;
                if (sum <= N)
                    dp[sum] = 1;
            }
        }
 
        // Return true if N can be represented as the sum of
        // two perfect cubes, false otherwise
        return dp[N] == 1;
    }
 
    // Main method
    public static void Main()
    {
        int N = 28;
 
        // Function call to check if N
        // can be represented as
        // sum of two perfect cubes or not
        if (SumOfTwoPerfectCubes(N)) {
            Console.WriteLine("True");
        }
        else {
            Console.WriteLine("False");
        }
    }
}
// This code is contributed by sarojmcy2e

                    

Javascript

function sumOfTwoPerfectCubes(N) {
  // DP array to store whether a number can be represented as the sum of two perfect cubes
  const dp = new Array(N + 1).fill(0);
 
  // Base case: 0 can be represented as the sum of two 0's
  dp[0] = 1;
 
  // Mark all numbers that can be represented as the sum of two perfect cubes
  for (let i = 1; i <= Math.floor(Math.pow(N, 1/3)); i++) {
    for (let j = 1; j <= Math.floor(Math.pow(N - Math.pow(i, 3), 1/3)); j++) {
      const sum = Math.pow(i, 3) + Math.pow(j, 3);
      if (sum <= N) {
        dp[sum] = 1;
      }
    }
  }
 
  // Return true if N can be represented as the sum of two perfect cubes, false otherwise
  return dp[N] === 1;
}
 
// Driver code
const N = 28;
 
// Function call to check if N
// can be represented as
// sum of two perfect cubes or not
if (sumOfTwoPerfectCubes(N)) {
  console.log("True");
} else {
  console.log("False");
}

                    

Output

True

Time Complexity: O(N^(2/3)), where N is the input number.
Auxiliary Space: O(N), as we are using a DP array of size N+1 to store



Last Updated : 19 Apr, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads