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

• Difficulty Level : Hard
• Last Updated : 21 Sep, 2021

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:

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

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:

• Initialize an ordered map, say cubes, to store the perfect cubes of first N natural numbers in sorted order.
• Traverse the map and check for the pair having a sum equal to N.
• 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 ``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 cubes = ``new` `HashMap<>();``    ``for` `(``int` `i = ``1``; i * i * i <= N; i++)``      ``cubes.put((i * i * i), i);` `    ``// Traverse the map``    ``Iterator > itr``      ``= cubes.entrySet().iterator();``    ``while` `(itr.hasNext())``    ``{``      ``Map.Entry 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.`

## 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;` `      ``// Stores second number``      ``int` `secondNumber = N - cubes;` `      ``// 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.`

## Javascript

 ``
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 other 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 ``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`

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

## Javascript

 ``
Output
`True`

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

Space Complexity : O(1)

My Personal Notes arrow_drop_up