Given a number n, the task is to find the largest perfect cube that can be formed by deleting minimum digits(possibly 0) from the number.

X is called a perfect cube if X = Y^{3} for some Y.

Examples:

Input : 4125 Output : 125Explanation125 = 5^{3}. We can form 125 by deleting digit 4 from 4125 Input : 876 Output :8Explanation8 = 2^{3}. We can form 8 by deleting digits 7 and 6 from 876

We can generate cubes of all numbers till from 1 to N^{1/3} (We don’t consider 0 as 0 is not considered as a perfect cube). We iterate the cubes from largest to the smallest.

Now if we look at the number n given to us, then we know that this number contains only log(n) + 1 digits, thus we can efficiently approach the problem if we treat this number n as a string hereafter.

While iterating on the perfect cubes, we check if the perfect cube is a subsequence of the number n when its represented as a string.If this is the case then the deletions required for changing the number n to the current perfect cube is:

No of deleted digits = No of digits in number n - Number of digits in current perfect cube

Since we want the largest cube number we traverse the array of preprocessed cubes in reverse order.

`/* C++ code to implement maximum perfect cube ` ` ` `formed after deleting minimum digits */` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Returns vector of Pre Processed perfect cubes ` `vector<string> preProcess(` `long` `long` `int` `n) ` `{ ` ` ` `vector<string> preProcessedCubes; ` ` ` `for` `(` `int` `i = 1; i * i * i <= n; i++) { ` ` ` `long` `long` `int` `iThCube = i * i * i; ` ` ` ` ` `// convert the cube to string and push into ` ` ` `// preProcessedCubes vector ` ` ` `string cubeString = to_string(iThCube); ` ` ` `preProcessedCubes.push_back(cubeString); ` ` ` `} ` ` ` `return` `preProcessedCubes; ` `} ` ` ` `/* Utility function for findLargestCube(). ` ` ` `Returns the Largest cube number that can be formed */` `string findLargestCubeUtil(string num, ` ` ` `vector<string> preProcessedCubes) ` `{ ` ` ` `// reverse the preProcessed cubes so that we ` ` ` `// have the largest cube in the beginning ` ` ` `// of the vector ` ` ` `reverse(preProcessedCubes.begin(), preProcessedCubes.end()); ` ` ` ` ` `int` `totalCubes = preProcessedCubes.size(); ` ` ` ` ` `// iterate over all cubes ` ` ` `for` `(` `int` `i = 0; i < totalCubes; i++) { ` ` ` `string currCube = preProcessedCubes[i]; ` ` ` ` ` `int` `digitsInCube = currCube.length(); ` ` ` `int` `index = 0; ` ` ` `int` `digitsInNumber = num.length(); ` ` ` `for` `(` `int` `j = 0; j < digitsInNumber; j++) { ` ` ` ` ` `// check if the current digit of the cube ` ` ` `// matches with that of the number num ` ` ` `if` `(num[j] == currCube[index]) ` ` ` `index++; ` ` ` ` ` `if` `(digitsInCube == index) ` ` ` `return` `currCube; ` ` ` `} ` ` ` `} ` ` ` ` ` `// if control reaches here, the its ` ` ` `// not possible to form a perfect cube ` ` ` `return` `"Not Possible"` `; ` `} ` ` ` `// wrapper for findLargestCubeUtil() ` `void` `findLargestCube(` `long` `long` `int` `n) ` `{ ` ` ` `// pre process perfect cubes ` ` ` `vector<string> preProcessedCubes = preProcess(n); ` ` ` ` ` `// convert number n to string ` ` ` `string num = to_string(n); ` ` ` ` ` `string ans = findLargestCubeUtil(num, preProcessedCubes); ` ` ` ` ` `cout << ` `"Largest Cube that can be formed from "` ` ` `<< n << ` `" is "` `<< ans << endl; ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `long` `long` `int` `n; ` ` ` `n = 4125; ` ` ` `findLargestCube(n); ` ` ` ` ` `n = 876; ` ` ` `findLargestCube(n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

Largest Cube that can be formed from 4125 is 125 Largest Cube that can be formed from 876 is 8

Time Complexity of the above algorithm is O(N^{1/3}log(N) log(N) is due to the fact that the number of digits in N are Log(N) + 1.

## Recommended Posts:

- Find maximum number that can be formed using digits of a given number
- Find the largest after deleting the given elements
- Find the k largest numbers after deleting the given elements
- Find the Largest number with given number of digits and sum of digits
- Find largest number smaller than N with same set of digits
- Minimum sum of two numbers formed from digits of an array
- Largest number in an array that is not a perfect cube
- Largest perfect cube number in an Array
- Recursive sum of digits of a number formed by repeated appends
- Minimum number of digits to be removed so that no two consecutive digits are same
- Find largest sum of digits in all divisors of n
- Largest number not greater than N all the digits of which are odd
- Largest number with the given set of N digits that is divisible by 2, 3 and 5
- Largest number with prime digits
- Largest palindromic number by permuting digits

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.