大于给定数字的完美立方

给定数字N，任务是找到下一个大于N的理想立方体。
例子：

Input: N = 6
Output: 8
8 is a greater number than 6 and
is also a perfect cube

Input: N = 9
Output: 27

方法：

1. 找到给定N的立方根。
2. 使用C++中的下限函数计算其下限值。
3. 然后添加1。
4. 打印该数字的多维数据集。

C++

// C++ implementation of above approach
#include 
#include 
using namespace std;
 
// Function to find the next perfect cube
int nextPerfectCube(int N)
{
    int nextN = floor(cbrt(N)) + 1;
 
    return nextN * nextN * nextN;
}
 
// Driver Code
int main()
{
    int n = 35;
 
    cout << nextPerfectCube(n);
    return 0;
}

Java

//Java implementation of above approach
import java.util.*;
import java.lang.*;
import java.io.*;
 
 
 
class GFG{
// Function to find the next perfect cube
static int nextPerfectCube(int N)
{
    int nextN = (int)Math.floor(Math.cbrt(N)) + 1;
  
    return nextN * nextN * nextN;
}
  
// Driver Code
public static void main(String args[])
{
    int n = 35;
  
    System.out.print(nextPerfectCube(n));
}
}

Python 3

# Python 3 implementation of above approach
 
# from math import everything
from math import *
 
# Function to find the next perfect cube
def nextPerfectCube(N) :
 
    nextN = floor(N ** (1/3)) + 1
 
    return nextN ** 3
 
 
# Driver code    
if __name__ == "__main__" :
 
    n = 35
    print(nextPerfectCube(n))
 
# This code is contributed by ANKITRAI1

C#

// C# implementation of above approach
using System;
class GFG
{
// Function to find the next perfect cube
static int nextPerfectCube(int N)
{
    int nextN = (int)Math.Floor(Math.Pow(N,
                         (double)1/3)) + 1;
 
    return nextN * nextN * nextN;
}
 
// Driver Code
public static void Main()
{
    int n = 35;
 
    Console.Write(nextPerfectCube(n));
}
}
 
// This code is contributed by ChitraNayal

Javascript

 
// Javascript implementation of above approach
 
// Function to find the next perfect cube
function nextPerfectCube(N)
{
    let nextN = Math.floor(Math.cbrt(N)) + 1;
 
    return nextN * nextN * nextN;
}
 
// Driver Code
let n = 35;
 
document.write(nextPerfectCube(n));
 

输出：

64

时间复杂度： O(1)

辅助空间： O(1)