Print N numbers such that their product is a Perfect Cube
Last Updated :
04 Oct, 2023
Given a number N, the task is to find distinct N numbers such that their product is a perfect cube.
Examples:
Input: N = 3
Output: 1, 8, 27
Explanation:
Product of the output numbers = 1 * 8 * 27 = 216, which is the perfect cube of 6 (63 = 216)
Input: N = 2
Output: 1 8
Explanation:
Product of the output numbers = 1 * 8 = 8, which is the perfect cube of 2 (23 = 8)
Approach: The solution is based on the fact that
The product of the first ‘N’ Perfect Cube numbers is always a Perfect Cube.
So, the Perfect Cube of first N natural numbers will be printed as the output.
For example:
For N = 1 => [1]
Product is 1
and cube root of 1 is also 1
For N = 2 => [1, 8]
Product is 8
and cube root of 8 is 2
For N = 3 => [1, 8, 27]
Product is 216
and cube root of 216 is 6
and so on
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void findNumbers( int N)
{
int i = 1;
while (i <= N) {
cout << (i * i * i)
<< " " ;
i++;
}
}
int main()
{
int N = 4;
findNumbers(N);
}
|
Java
import java.util.*;
class GFG
{
static void findNumbers( int N)
{
int i = 1 ;
while (i <= N) {
System.out.print( (i * i * i)
+ " " );
i++;
}
}
public static void main (String []args)
{
int N = 4 ;
findNumbers(N);
}
}
|
Python3
def findNumbers(N):
i = 1
while (i < = N):
print ((i * i * i), end = " " )
i + = 1
if __name__ = = '__main__' :
N = 4
findNumbers(N)
|
C#
using System;
class GFG
{
static void findNumbers( int N)
{
int i = 1;
while (i <= N) {
Console.Write( (i * i * i)
+ " " );
i++;
}
}
public static void Main ( string []args)
{
int N = 4;
findNumbers(N);
}
}
|
Javascript
<script>
function findNumbers(N)
{
let i = 1;
while (i <= N) {
document.write((i * i * i)
+ " " );
i++;
}
}
let N = 4;
findNumbers(N);
</script>
|
Performance Analysis:
- Time Complexity: As in the above approach, we are finding the Perfect Cube of N numbers, therefore it will take O(N) time.
- Auxiliary Space Complexity: As in the above approach, there are no extra space used; therefore the Auxiliary Space complexity will be O(1).
Approach#2: Using math
This approach iterates through numbers starting from 1 and checks if their cube root is an integer. If it is, then the number is a perfect cube and is printed. The loop continues until n such perfect cubes have been printed.
Algorithm
1. Initialize the count to 0 and i to 1.
2. While count is less than n, do the following:
a. Check if the cube root of i is an integer by comparing the float value of the cube root with its integer value.
b. If the cube root is an integer, print the number i and increment the count.
c. Increment i by 1 after each iteration of the loop.
3. Print a newline character after all the perfect cube numbers have been printed.
C++
#include <iostream>
#include <cmath>
using namespace std;
void print_cube_numbers( int n) {
int count = 0;
int i = 1;
while (count < n) {
int cube_root = round(cbrt(i));
if (cube_root * cube_root * cube_root == i) {
cout << i << " " ;
count++;
}
i++;
}
cout << endl;
}
int main() {
print_cube_numbers(3);
print_cube_numbers(2);
return 0;
}
|
Java
import java.util.*;
public class GFG {
public static void printCubeNumbers( int n) {
int count = 0 ;
int i = 1 ;
while (count < n) {
int cubeRoot = ( int ) Math.round(Math.cbrt(i));
if (cubeRoot * cubeRoot * cubeRoot == i) {
System.out.print(i + " " );
count++;
}
i++;
}
System.out.println();
}
public static void main(String[] args) {
printCubeNumbers( 3 );
printCubeNumbers( 2 );
}
}
|
Python3
import math
def print_cube_numbers(n):
count = 0
i = 1
while count < n:
if math. pow (i, 1 / 3 ) = = int (math. pow (i, 1 / 3 )):
print (i, end = " " )
count + = 1
i + = 1
print ()
print_cube_numbers( 3 )
print_cube_numbers( 2 )
|
C#
using System;
class Program
{
static void PrintCubeNumbers( int n)
{
int count = 0;
int i = 1;
while (count < n)
{
int cubeRoot = ( int )Math.Round(Math.Cbrt(i));
if (cubeRoot * cubeRoot * cubeRoot == i)
{
Console.Write(i + " " );
count++;
}
i++;
}
Console.WriteLine();
}
static void Main()
{
PrintCubeNumbers(3);
PrintCubeNumbers(2);
}
}
|
Javascript
function printCubeNumbers(n) {
let count = 0;
let i = 1;
while (count < n) {
let cubeRoot = Math.round(Math.cbrt(i));
if (Math.pow(cubeRoot, 3) === i) {
process.stdout.write(i + " " );
count++;
}
i++;
}
console.log();
}
function main() {
printCubeNumbers(3);
printCubeNumbers(2);
}
main();
|
Time Complexity: O(N^2/3) because it iterates through numbers from 1 to N and checks the cube root of each number, which takes O(N^1/3) time. Therefore, the overall time complexity is O(N^2/3).
Auxiliary Space: O(1) because it uses constant space to store the variables count and i, and no additional data structures are used.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...