Previous perfect square and cube number smaller than number N

0 0 4 minutes read

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)

Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 zambiatek!