Skip to content
Related Articles

Related Articles

Improve Article
Previous perfect square and cube number smaller than number N
  • Last Updated : 26 Mar, 2021

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 alreay 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 alreay 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 alreay 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 alreay 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 alreay 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 alreay 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 alreay 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 alreay 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 alreay 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 alreay 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(sqrt(n))

Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :