Número de veces que el cubo perfecto más grande se puede restar de N

Dado un número N , en cada paso, reste el cubo perfecto más grande (≤ N) de N. Repita este paso mientras N > 0 . La tarea es contar el número de pasos que se pueden realizar. 

Ejemplos:  

Entrada: N = 100 
Salida: 4 
Primer paso, 100 – (4 * 4 * 4) = 100 – 64 = 36 
Segundo paso, 36 – (3 * 3 * 3) = 36 – 27 = 9 
Tercer paso, 9 – ( 2 * 2 * 2) = 9 – 8 = 1 
Cuarto paso, 1 – (1 * 1 * 1) = 1 – 1 = 0

Entrada: N = 150 
Salida: 5 
Primer paso, 150 – (5 * 5 * 5) = 150 – 125 = 25 
Segundo paso, 25 – (2 * 2 * 2) = 25 – 8 = 17 
Tercer paso, 17 – ( 2 * 2 * 2) = 17 – 8 = 9 
Cuarto paso, 9 – (2 * 2 * 2) = 9 – 8 = 1 
Quinto paso, 1 – (1 * 1 * 1) = 1 – 1 = 0 

Enfoque :  

• Obtenga el número del cual se debe reducir el cubo perfecto más grande.
• Encuentra la raíz cúbica del número y convierte el resultado en un número entero. La raíz cúbica del número puede contener alguna fracción después del decimal, lo que debe evitarse.
• Resta el cubo del entero encontrado en el paso anterior. Esto eliminaría el cubo perfecto más grande posible del número en el paso anterior. 

N = N - ((int) ∛N)3

• Repita los dos pasos anteriores con el número reducido, hasta que sea mayor que 0.
• Imprime el número de veces que un cubo perfecto se ha reducido de N. Este es el resultado final.

A continuación se muestra la implementación del enfoque anterior:  

// C++ implementation of the approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the count of steps
int countSteps(int n)
{
 
    // Variable to store the count of steps
    int steps = 0;
 
    // Iterate while N > 0
    while (n) {
 
        // Get the largest perfect cube
        // and subtract it from N
        int largest = cbrt(n);
        n -= (largest * largest * largest);
 
        // Increment steps
        steps++;
    }
 
    // Return the required count
    return steps;
}
 
// Driver code
int main()
{
    int n = 150;
    cout << countSteps(n);
 
    return 0;
}

// Java implementation of the approach
class GFG{
  
// Function to return the count of steps
static int countSteps(int n)
{
  
    // Variable to store the count of steps
    int steps = 0;
  
    // Iterate while N > 0
    while (n > 0) {
  
        // Get the largest perfect cube
        // and subtract it from N
        int largest = (int) Math.cbrt(n);
        n -= (largest * largest * largest);
  
        // Increment steps
        steps++;
    }
  
    // Return the required count
    return steps;
}
  
// Driver code
public static void main(String[] args)
{
    int n = 150;
    System.out.print(countSteps(n));
}
}
 
// This code is contributed by 29AjayKumar

# Python3 implementation of the approach
from math import floor
 
# Function to return the count of steps
def countSteps(n):
 
    # Variable to store the count of steps
    steps = 0
 
    # Iterate while N > 0
    while (n):
 
        # Get the largest perfect cube
        # and subtract it from N
        largest = floor(n**(1/3))
        n -= (largest * largest * largest)
 
        # Increment steps
        steps += 1
 
    # Return the required count
    return steps
 
# Driver code
n = 150
print(countSteps(n))
 
# This code is contributed by mohit kumar 29

// C# implementation of the approach
using System;
 
class GFG{
   
// Function to return the count of steps
static int countSteps(int n)
{
   
    // Variable to store the count of steps
    int steps = 0;
   
    // Iterate while N > 0
    while (n > 0) {
   
        // Get the largest perfect cube
        // and subtract it from N
        int largest = (int) Math.Pow(n,(double)1/3);
        n -= (largest * largest * largest);
   
        // Increment steps
        steps++;
    }
   
    // Return the required count
    return steps;
}
   
// Driver code
public static void Main(String[] args)
{
    int n = 150;
    Console.Write(countSteps(n));
}
}
 
// This code is contributed by PrinciRaj1992

<script>
 
// JavaScript implementation of the approach
 
// Function to return the count of steps
function countSteps(n)
{
     
    // Variable to store the count of steps
    let steps = 0;
 
    // Iterate while N > 0
    while (n)
    {
         
        // Get the largest perfect cube
        // and subtract it from N
        let largest = Math.floor(Math.cbrt(n));
        n -= (largest * largest * largest);
 
        // Increment steps
        steps++;
    }
 
    // Return the required count
    return steps;
}
 
// Driver code
let n = 150;
 
document.write(countSteps(n));
 
// This code is contributed by Manoj.
 
</script>

5