# Sphenic Number

• Difficulty Level : Easy
• Last Updated : 23 Jun, 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 weather 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;``// 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={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] && arr[arr1] && arr[arr1]))``    ``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``;``  ` `// 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``;  ``    ` `    ``// 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] &&``      ``arr[arr1] && arr[arr1]))``        ``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