Previous perfect square and cube number smaller than number N

Given an integer N, the task is to find the previous perfect square or perfect cube smaller than the number N.
Examples: 

Input: N = 6 
Output:
Perfect Square = 4 
Perfect Cube = 1

Input: N = 30 
Output:
Perfect Square = 25 
Perfect Cube = 27 

Approach: Previous perfect square number less than N can be computed as follows:  

• Find the square root of given number N.
• Calculate its floor value using floor function of the respective language.
• Then subtract 1 from it if N is already a perfect square.
• Print square of that number.

Previous perfect cube number less than N can be computed as follows:  

• Find the cube root of given N.
• Calculate its floor value using floor function of the respective language.
• Then subtract 1 from it if N is already a perfect cube.
• Print cube of that number.

Below is the implementation of above approach:  

C++

// C++ implementation to find the
// previous perfect square and cube
// smaller than the given number

#include <cmath>
#include <iostream>

using namespace std;

// Function to find the previous
// perfect square of the number N
int previousPerfectSquare(int N)
{
    int prevN = floor(sqrt(N));

    // If N is already a perfect square
    // decrease prevN by 1.
    if (prevN * prevN == N)
        prevN -= 1;

    return prevN * prevN;
}

// Function to find the
// previous perfect cube
int previousPerfectCube(int N)
{
    int prevN = floor(cbrt(N));

    // If N is already a perfect cube
    // decrease prevN by 1.
    if (prevN * prevN * prevN == N)
        prevN -= 1;

    return prevN * prevN * prevN;
}

// Driver Code
int main()
{
    int n = 30;
    cout << previousPerfectSquare(n) << "\n";
    cout << previousPerfectCube(n) << "\n";
    return 0;
}

Java

// Java implementation to find the
// previous perfect square and cube
// smaller than the given number
import java.util.*;

class GFG{

// Function to find the previous
// perfect square of the number N
static int previousPerfectSquare(int N)
{
    int prevN = (int)Math.floor(Math.sqrt(N));

    // If N is already a perfect square
    // decrease prevN by 1.
    if (prevN * prevN == N)
        prevN -= 1;

    return prevN * prevN;
}

// Function to find the
// previous perfect cube
static int previousPerfectCube(int N)
{
    int prevN = (int)Math.floor(Math.cbrt(N));

    // If N is already a perfect cube
    // decrease prevN by 1.
    if (prevN * prevN * prevN == N)
        prevN -= 1;

    return prevN * prevN * prevN;
}

// Driver Code
public static void main(String[] args)
{
    int n = 30;
    System.out.println(previousPerfectSquare(n));
    System.out.println(previousPerfectCube(n));
}
}

// This code is contributed by Rohit_ranjan

Python3

# Python3 implementation to find the
# previous perfect square and cube
# smaller than the given number
import math
import numpy as np

# Function to find the previous
# perfect square of the number N
def previousPerfectSquare(N):

    prevN = math.floor(math.sqrt(N));

    # If N is already a perfect square
    # decrease prevN by 1.
    if (prevN * prevN == N):
        prevN -= 1;

    return prevN * prevN;

# Function to find the
# previous perfect cube
def previousPerfectCube(N):

    prevN = math.floor(np.cbrt(N));

    # If N is already a perfect cube
    # decrease prevN by 1.
    if (prevN * prevN * prevN == N):
        prevN -= 1;

    return prevN * prevN * prevN;

# Driver Code
n = 30;

print(previousPerfectSquare(n));
print(previousPerfectCube(n));

# This code is contributed by Code_Mech

C#

// C# implementation to find the
// previous perfect square and cube
// smaller than the given number
using System;

class GFG{

// Function to find the previous
// perfect square of the number N
static int previousPerfectSquare(int N)
{
    int prevN = (int)Math.Floor(Math.Sqrt(N));

    // If N is already a perfect square
    // decrease prevN by 1.
    if (prevN * prevN == N)
        prevN -= 1;

    return prevN * prevN;
}

// Function to find the
// previous perfect cube
static int previousPerfectCube(int N)
{
    int prevN = (int)Math.Floor(Math.Cbrt(N));

    // If N is already a perfect cube
    // decrease prevN by 1.
    if (prevN * prevN * prevN == N)
        prevN -= 1;

    return prevN * prevN * prevN;
}

// Driver Code
public static void Main(String[] args)
{
    int n = 30;

    Console.WriteLine(previousPerfectSquare(n));
    Console.WriteLine(previousPerfectCube(n));
}
}

// This code is contributed by sapnasingh4991

Javascript

<script>
// JavaScript implementation to find the
// previous perfect square and cube
// smaller than the given number

// Function to find the previous
// perfect square of the number N
function previousPerfectSquare(N)
{
    let prevN = Math.floor(Math.sqrt(N));

    // If N is already a perfect square
    // decrease prevN by 1.
    if (prevN * prevN == N)
        prevN -= 1;

    return prevN * prevN;
}

// Function to find the
// previous perfect cube
function previousPerfectCube(N)
{
    let prevN = Math.floor(Math.cbrt(N));

    // If N is already a perfect cube
    // decrease prevN by 1.
    if (prevN * prevN * prevN == N)
        prevN -= 1;

    return prevN * prevN * prevN;
}

// Driver Code
    let n = 30;
    document.write(previousPerfectSquare(n) + "<br>");
    document.write(previousPerfectCube(n) + "<br>");

// This code is contributed by Manoj.
</script>

Output:

25
27

Time Complexity: O(log(n))
Auxiliary Space: O(1)