Open in App
Not now

# Sphenic Number

• Difficulty Level : Easy
• Last Updated : 16 Sep, 2022

A Sphenic Number is a positive integer n which is product of exactly three distinct primes. The first few sphenic numbers are 30, 42, 66, 70, 78, 102, 105, 110, 114, …
Given a number n, determine whether it is a Sphenic Number or not.

Examples:

```Input : 30
Output : Yes
Explanation : 30 is the smallest Sphenic number,
30 = 2 Ã— 3 Ã— 5
the product of the smallest three primes

Input : 60
Output : No
Explanation : 60 = 22 x 3 x 5
has exactly 3 prime factors but
is not a sphenic number```
Recommended Practice

Sphenic number can be checked by fact that every sphenic number will have exactly 8 divisor SPHENIC NUMBER
So first We will try to find if the number is having exactly 8 divisors if not then simply answer is no.If there are exactly 8 divisors then we will confirm whether the first 3 digits after 1 are prime or not.
Eg. 30 (sphenic number)
30=p*q*r(i.e p,q and r are three distinct prime no and their product are 30)
the set of divisor is (1,2,3,5,6,10,15,30).

Below is the implementation of the idea.

## C++

 `// C++ program to check whether a number is a` `// Sphenic number or not` `#include` `using` `namespace` `std;` `//create a global array of size 10001;` `bool` `arr[1001];` `// This functions finds all primes smaller than 'limit' ` `// using simple sieve of eratosthenes. ` `void` `simpleSieve() ` `{` `    ``// initialize all entries of it as true. A value ` `    ``// in mark[p] will finally be false if 'p' is Not ` `    ``// a prime, else true.` `    ``memset``(arr,``true``,``sizeof``(arr));`   `    ``// One by one traverse all numbers so that their ` `    ``// multiples can be marked as composite. ` `    ``for``(``int` `p=2;p*p<1001;p++)` `    ``{  ` `        ``// If p is not changed, then it is a prime` `        ``if``(arr[p])` `        ``{``// Update all multiples of p ` `            ``for``(``int` `i=p*2;i<1001;i=i+p)` `            ``arr[i]=``false``;` `        ``}` `    ``}` `}` `int` `find_sphene(``int` `N)` `{` `    ``int` `arr1[8]={0};   ``//to store the 8 divisors` `    ``int` `count=0;        ``//to count the number of divisor` `    ``int` `j=0;` `    ``for``(``int` `i=1;i<=N;i++)     ` `    ``{` `        ``if``(N%i==0 &&count<9)        ` `        ``{` `            ``count++;` `            ``arr1[j++]=i;` `        ``}` `    ``}` `    ``//finally check if there re 8 divisor and all the numbers are distinct prime no return 1` `    ``//else return 0` `    ``if``(count==8 && (arr[arr1[1]] && arr[arr1[2]] && arr[arr1[3]]))` `    ``return` `1;` `    ``return` `0;` `}`   `// Driver program to test above function ` `int` `main() ` `{ ` `    ``int` `n = 60; ` `    ``simpleSieve();` `    ``int` `ans=find_sphene(n);` `    ``if``(ans)` `    ``cout<<``"Yes"``;` `    ``else` `    ``cout<<``"NO"``;` `} `

## Java

 `// Java program to check whether a number is a` `// Sphenic number or not` `import` `java.util.*;`   `class` `GFG` `{` `  `  `// create a global array of size 10001;` `static` `boolean` `[]arr = ``new` `boolean``[``1001``];` `  `  `// This functions finds all primes smaller than 'limit' ` `// using simple sieve of eratosthenes. ` `static` `void` `simpleSieve() ` `{` `    ``// initialize all entries of it as true. A value ` `    ``// in mark[p] will finally be false if 'p' is Not ` `    ``// a prime, else true.` `    ``Arrays.fill(arr, ``true``);`   `    ``// One by one traverse all numbers so that their ` `    ``// multiples can be marked as composite. ` `    ``for``(``int` `p = ``2``; p * p < ``1001``; p++)` `    ``{` `      `  `        ``// If p is not changed, then it is a prime` `        ``if``(arr[p])` `        ``{` `          `  `          ``// Update all multiples of p ` `            ``for``(``int` `i = p * ``2``; i < ``1001``; i = i + p)` `            ``arr[i] = ``false``;` `        ``}` `    ``}` `}` `static` `int` `find_sphene(``int` `N)` `{` `    ``int` `[]arr1 = ``new` `int``[``8``];   ``// to store the 8 divisors` `    ``int` `count = ``0``;        ``// to count the number of divisor` `    ``int` `j = ``0``;` `    ``for``(``int` `i = ``1``; i <= N; i++)     ` `    ``{` `        ``if``(N % i == ``0` `&& count < ``8``)        ` `        ``{` `            ``count++;` `            ``arr1[j++] = i;` `            `  `        ``}` `    ``}` `  `  `    ``// finally check if there re 8 divisor and ` `    ``// all the numbers are distinct prime no return 1` `    ``// else return 0);` `    ``if``(count == ``8` `&& (arr[arr1[``1``]] && arr[arr1[``2``]] && arr[arr1[``3``]]))` `      ``return` `1``;` `    `  `    ``return` `0``;` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``60``; ` `    ``simpleSieve();` `    ``int` `ans = find_sphene(n);` `    ``if``(ans == ``1``)` `      ``System.out.print(``"Yes"``);` `    ``else` `      ``System.out.print(``"NO"``);` `} ` `}`   `// This code is contributed by aashish1995`

## Python3

 `# Python3 program to check whether a number ` `# is a Sphenic number or not`   `# Create a global array of size 1001;` `arr ``=` `[``True``] ``*` `(``1001``)`   `# This functions finds all primes smaller ` `# than 'limit' using simple sieve of ` `# eratosthenes.` `def` `simpleSieve():` `    `  `    ``# Initialize all entries of it as ` `    ``# True. A value in mark[p] will ` `    ``# finally be False if 'p' is Not` `    ``# a prime, else True.` `    ``k ``=` `0`   `    ``# One by one traverse all numbers so ` `    ``# that their multiples can be marked` `    ``# as composite.` `    ``for` `p ``in` `range``(``2``, ``1001``):` `        ``if` `(p ``*` `p > ``1001``):` `            ``break` `            `  `        ``# If p is not changed, then it is a prime` `        ``if` `(arr[p]):`   `            ``# Update all multiples of p` `            ``for` `k ``in` `range``(p, ``1001``, k ``+` `p):` `                ``arr[k] ``=` `False` `        `  `def` `find_sphene(N):` `    `  `    ``# To store the 8 divisors` `    ``arr1 ``=` `[``0``] ``*` `(``8``) ` `    `  `    ``# To count the number of divisor` `    ``count ``=` `0` `    ``j ``=` `0` `    `  `    ``for` `i ``in` `range``(``1``, N ``+` `1``):` `        ``if` `(N ``%` `i ``=``=` `0` `and` `count < ``8``):` `            ``count ``+``=` `1` `            ``arr1[j] ``=` `i` `            ``j ``+``=` `1` `            `  `    ``# Finally check if there re 8 divisor and` `    ``# all the numbers are distinct prime no return 1` `    ``# else return 0);` `    ``if` `(count ``=``=` `8` `and` `(arr[arr1[``1``]] ``and` `       ``arr[arr1[``2``]] ``and` `arr[arr1[``3``]])):` `        ``return` `1``;`   `    ``return` `0``;`   `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``n ``=` `60` `    ``simpleSieve()` `    ``ans ``=` `find_sphene(n)` `    `  `    ``if` `(ans ``=``=` `1``):` `        ``print``(``"Yes"``)` `    ``else``:` `        ``print``(``"NO"``)`   `# This code is contributed by gauravrajput1`

## C#

 `// C# program to check whether a number ` `// is a Sphenic number or not` `using` `System;`   `class` `GFG{` `  `  `// Create a global array of size 10001;` `static` `bool` `[]arr = ``new` `bool``[1001];` `  `  `// This functions finds all primes smaller than` `// 'limit'. Using simple sieve of eratosthenes. ` `static` `void` `simpleSieve() ` `{` `    `  `    ``// Initialize all entries of it as true. ` `    ``// A value in mark[p] will finally be ` `    ``// false if 'p' is Not a prime, else true.` `    ``for``(``int` `i = 0;i<1001;i++)` `        ``arr[i] = ``true``;` `        `  `    ``// One by one traverse all numbers so ` `    ``// that their multiples can be marked ` `    ``// as composite. ` `    ``for``(``int` `p = 2; p * p < 1001; p++)` `    ``{` `        `  `        ``// If p is not changed, then it` `        ``// is a prime` `        ``if` `(arr[p])` `        ``{` `            `  `            ``// Update all multiples of p ` `            ``for``(``int` `i = p * 2; i < 1001; i = i + p)` `                ``arr[i] = ``false``;` `        ``}` `    ``}` `}`   `static` `int` `find_sphene(``int` `N)` `{` `    `  `    ``// To store the 8 divisors` `    ``int` `[]arr1 = ``new` `int``[8];   ` `    `  `    ``// To count the number of divisor` `    ``int` `count = 0;        ` `    ``int` `j = 0;` `    `  `    ``for``(``int` `i = 1; i <= N; i++)     ` `    ``{` `        ``if` `(N % i == 0 && count < 8)        ` `        ``{` `            ``count++;` `            ``arr1[j++] = i;` `        ``}` `    ``}` `  `  `    ``// Finally check if there re 8 divisor ` `    ``// and all the numbers are distinct prime` `    ``// no return 1 else return 0);` `    ``if` `(count == 8 && (arr[arr1[1]] && ` `      ``arr[arr1[2]] && arr[arr1[3]]))` `        ``return` `1;` `    `  `    ``return` `0;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `n = 60; ` `    ``simpleSieve();` `    ``int` `ans = find_sphene(n);` `    `  `    ``if` `(ans == 1)` `        ``Console.Write(``"Yes"``);` `    ``else` `        ``Console.Write(``"NO"``);` `} ` `}`   `// This code is contributed by aashish1995`

## Javascript

 ``

Output:

`NO`

Time Complexity: O(âˆšp log p)
Auxiliary Space: O(n)

References:
1. OEIS
2. https://en.wikipedia.org/wiki/Sphenic_number

This article is contributed by Aarti_Rathi and mra11145. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

My Personal Notes arrow_drop_up
Related Articles