# Sphenic Number

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

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.

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 geeks!

Previous
Next