Números menores que N que son cubos perfectos y la suma de sus dígitos reducida a un solo dígito es 1

Dado un número n , la tarea es imprimir todos los números menores o iguales a n que sean cubos perfectos y que la suma final de sus dígitos sea 1 .
Ejemplos: 
 

Entrada: n = 100 
Salida: 1 64 
64 = 6 + 4 = 10 = 1 + 0 = 1 
Entrada: n = 1000 
Salida: 1 64 343 1000 
 

Enfoque: para cada cubo perfecto menor o igual que n , siga calculando la suma de sus dígitos hasta que el número se reduzca a un solo dígito (enfoque O (1) aquí ), si este dígito es 1, imprima el cubo perfecto, de lo contrario, omita al siguiente cubo perfecto por debajo de n hasta que se hayan considerado todos los cubos perfectos.
A continuación se muestra la implementación del enfoque anterior:
 

// C++ implementation of the approach
#include <cmath>
#include <iostream>
using namespace std;
 
// Function that returns true if the eventual
// digit sum of number nm is 1
bool isDigitSumOne(int nm)
{
   //if reminder will 1
   //then eventual sum is 1
    if (nm % 9 == 1)
        return true;
    else
        return false;
}
 
// Function to print the required numbers
// less than n
void printValidNums(int n)
{
    int cbrt_n = (int)cbrt(n);
    for (int i = 1; i <= cbrt_n; i++) {
        int cube = pow(i, 3);
 
        // If it is the required perfect cube
        if (cube >= 1 && cube <= n && isDigitSumOne(cube))
            cout << cube << " ";
    }
}
 
// Driver code
int main()
{
    int n = 1000;
    printValidNums(n);
    return 0;
}

// Java implementation of the approach
class GFG {
 
    // Function that returns true if the eventual
    // digit sum of number nm is 1
    static boolean isDigitSumOne(int nm)
    {
 
      //if reminder will 1
      //then eventual sum is 1
      if (nm % 9 == 1)
        return true;
      else
        return false;
    }
 
    // Function to print the required numbers
    // less than n
    static void printValidNums(int n)
    {
        int cbrt_n = (int)Math.cbrt(n);
        for (int i = 1; i <= cbrt_n; i++) {
            int cube = (int)Math.pow(i, 3);
 
            // If it is the required perfect cube
            if (cube >= 1 && cube <= n && isDigitSumOne(cube))
                System.out.print(cube + " ");
        }
    }
 
    // Driver code
    public static void main(String args[])
    {
        int n = 1000;
        printValidNums(n);
    }
}

# Python3 implementation of the approach
import math
 
# Function that returns true if the eventual
# digit sum of number nm is 1
def isDigitSumOne(nm) :
   #if reminder will 1
   #then eventual sum is 1
    if(nm % 9 == 1):
        return True
    else:
        return False
 
# Function to print the required numbers
# less than n
def printValidNums(n):
    cbrt_n = math.ceil(n**(1./3.))
    for i in range(1, cbrt_n + 1):
        cube = i * i * i
        if (cube >= 1 and cube <= n and isDigitSumOne(cube)):
            print(cube, end = " ")
             
 
# Driver code
n = 1000
printValidNums(n)

// C# implementation of the approach
using System;
 
class GFG
{
    // Function that returns true if the
    // eventual digit sum of number nm is 1
    static bool isDigitSumOne(int nm)
    {
 
     //if reminder will 1
     //then eventual sum is 1
      if (nm % 9 == 1)
         return true;
      else
         return false;
    }
 
    // Function to print the required
    // numbers less than n
    static void printValidNums(int n)
    {
        int cbrt_n = (int)Math.Ceiling(Math.Pow(n,
                                      (double) 1 / 3));
        for (int i = 1; i <= cbrt_n; i++)
        {
            int cube = (int)Math.Pow(i, 3);
 
            // If it is the required perfect cube
            if (cube >= 1 && cube <= n &&
                             isDigitSumOne(cube))
                Console.Write(cube + " ");
        }
    }
 
    // Driver code
    static public void Main ()
    {
        int n = 1000;
        printValidNums(n);
    }
}
 
// This code is contributed by akt_mit

<?php
// PHP implementation of the approach
 
// Function that returns true if the
// eventual digit sum of number nm is 1
function isDigitSumOne($nm)
{
     //if reminder will 1
    //then eventual sum is 1
    if ($nm % 9 == 1)
        return true;
    else
        return false;
}
 
// Function to print the required numbers
// less than n
function printValidNums($n)
{
    $cbrt_n = ceil(pow($n,1/3));
    for ($i = 1; $i <= $cbrt_n; $i++)
    {
        $cube = pow($i, 3);
 
        // If it is the required perfect cube
        if ($cube >= 1 && $cube <= $n &&
                    isDigitSumOne($cube))
            echo $cube, " ";
    }
}
 
// Driver code
$n = 1000;
printValidNums($n);
 
// This code is contributed by Ryuga
?>

<script>
    // Javascript implementation of the approach
     
    // Function that returns true if the
    // eventual digit sum of number nm is 1
    function isDigitSumOne(nm)
    {
   
     //if reminder will 1
     //then eventual sum is 1
      if (nm % 9 == 1)
         return true;
      else
         return false;
    }
   
    // Function to print the required
    // numbers less than n
    function printValidNums(n)
    {
        let cbrt_n = Math.ceil(Math.pow(n, 1 / 3));
        for (let i = 1; i <= cbrt_n; i++)
        {
            let cube = Math.pow(i, 3);
   
            // If it is the required perfect cube
            if (cube >= 1 && cube <= n && isDigitSumOne(cube))
                document.write(cube + " ");
        }
    }
     
    let n = 1000;
      printValidNums(n);
     
</script>

1 64 343 1000

Complejidad de tiempo: O(cbrt(n))

Espacio Auxiliar: O(1)