# Find the Largest Cube formed by Deleting minimum Digits from a number

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++

`/* 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*

## Python3

# Python3 code to implement maximum perfect

# cube formed after deleting minimum digits

import math as mt

# Returns vector of Pre Processed

# perfect cubes

def preProcess(n):

preProcessedCubes = list()

for i in range(1, mt.ceil(n**(1. / 3.))):

iThCube = i**3

# convert the cube to string and

# push into preProcessedCubes vector

cubeString = str(iThCube)

preProcessedCubes.append(cubeString)

return preProcessedCubes

# Utility function for findLargestCube().

# Returns the Largest cube number that

# can be formed

def findLargestCubeUtil(num,preProcessedCubes):

# reverse the preProcessed cubes so

# that we have the largest cube in

# the beginning of the vector

preProcessedCubes = preProcessedCubes[::-1]

totalCubes = len(preProcessedCubes)

# iterate over all cubes

for i in range(totalCubes):

currCube = preProcessedCubes[i]

digitsInCube = len(currCube)

index = 0

digitsInNumber = len(num)

for j in range(digitsInNumber):

# check if the current digit of the cube

# matches with that of the number num

if (num[j] == currCube[index]):

index += 1

if (digitsInCube == index):

return currCube

# if control reaches here, the its

# not possible to form a perfect cube

return “Not Possible”

# wrapper for findLargestCubeUtil()

def findLargestCube(n):

# pre process perfect cubes

preProcessedCubes = preProcess(n)

num = str(n)

ans = findLargestCubeUtil(num, preProcessedCubes)

print(“Largest Cube that can be formed from”,

n, “is”, ans)

# Driver Code

n = 4125

findLargestCube(n)

n = 876

findLargestCube(n)

# This code is contributed

# by mohit kumar 29

**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 perfect cube number in an Array
- Largest number in an array that is not a perfect cube
- Find the count of numbers that can be formed using digits 3, 4 only and having length at max N.
- Greatest number less than equal to B that can be formed from the digits of A
- 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
- Minimum number of consecutive sequences that can be formed in an array
- Largest number not greater than N all the digits of which are odd

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.