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³ for some Y.

Examples:

Input : 4125
Output : 125
Explanation
125 = 53. We can form 125 by deleting digit 4 from 4125

Input : 876
Output :8
Explanation
8 = 23. 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;
}

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/3log(N) log(N) is due to the fact that the number of digits in N are Log(N) + 1.

sirjan13

Check out this Author's contributed articles.