Skip to content
Related Articles
Count numbers up to N having exactly 5 divisors
• Last Updated : 19 May, 2021

Given a positive integer N, the task is to count the number of integers from the range [1, N] having exactly 5 divisors.

Examples:

Input: N = 18
Output: 1
Explanation:
From all the integers over the range [1, 18], 16 is the only integer that has exactly 5 divisors, i.e. 1, 2, 8, 4 and 16.
Therefore, the count of such integers is 1.

Input: N = 100
Output: 2

Naive Approach: The simplest approach to solve the given problem is to iterate over the range [1, N] and count those integers in this range having the count of divisors as 5
Time Complexity: O(N4/3)
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized by observing a fact that the numbers that have exactly 5 divisors can be expressed in the form of p4, where p is a prime number as the count of divisors is exactly 5. Follow the below steps to solve the problem:

• Generate all primes such that their fourth power is less than 1018  by using Sieve of Eratosthenes and store it in vector, say A[].
• Initialize two variables, say low as 0 and high as A.size() – 1.
• For performing the Binary Search iterate until low is less than high and perform the following steps:
• Find the value of mid as the (low + high)/2.
• Find the value of fourth power of element at indices mid (mid – 1) and store it in a variable, say current and previous respectively.
• If the value of current is N, then print the value of A[mid] as the result.
• If the value of current is greater than N and previous is at most N, then print the value of A[mid] as the result.
• If the value of current is greater than N then update the value of high as (mid – 1). Otherwise, update the value of low as (mid + 1).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `#define ll long long int` `const` `int` `MAX = 1e5;` `using` `namespace` `std;`   `// Function to calculate the value of` `// (x^y) using binary exponentiation` `ll power(ll x, unsigned ll y)` `{` `    ``// Stores the value of x^y` `    ``ll res = 1;`   `    ``// Base Case` `    ``if` `(x == 0)` `        ``return` `0;`   `    ``while` `(y > 0) {`   `        ``// If y is odd multiply` `        ``// x with result` `        ``if` `(y & 1)` `            ``res = (res * x);`   `        ``// Otherwise, divide y by 2` `        ``y = y >> 1;`   `        ``x = (x * x);` `    ``}` `    ``return` `res;` `}`   `// Function to perform the Sieve Of` `// Eratosthenes to find the prime` `// number over the range [1, 10^5]` `void` `SieveOfEratosthenes(` `    ``vector >& v)` `{` `    ``bool` `prime[MAX + 1];`   `    ``memset``(prime, ``true``, ``sizeof``(prime));`   `    ``prime = ``false``;`   `    ``for` `(``int` `p = 2; p * p <= MAX; p++) {`   `        ``// If prime[p] is not changed` `        ``// then it is a prime` `        ``if` `(prime[p] == ``true``) {`   `            ``// Set all the multiples of` `            ``// p to non-prime` `            ``for` `(``int` `i = p * 2;` `                 ``i <= MAX; i += p)` `                ``prime[i] = ``false``;` `        ``}` `    ``}`   `    ``int` `num = 1;`   `    ``// Iterate over the range [1, MAX]` `    ``for` `(``int` `i = 1; i <= MAX; i++) {`   `        ``// Store all the prime number` `        ``if` `(prime[i]) {` `            ``v.push_back({ i, num });` `            ``num++;` `        ``}` `    ``}` `}`   `// Function to find the primes having` `// only 5 divisors` `int` `countIntegers(ll n)` `{` `    ``// Base Case` `    ``if` `(n < 16) {` `        ``return` `0;` `    ``}`   `    ``// First value of the pair has the` `    ``// prime number and the second value` `    ``// has the count of primes till that` `    ``// prime numbers` `    ``vector > v;`   `    ``// Precomputing all the primes` `    ``SieveOfEratosthenes(v);`   `    ``int` `low = 0;` `    ``int` `high = v.size() - 1;`   `    ``// Perform the Binary search` `    ``while` `(low <= high) {`   `        ``int` `mid = (low + high) / 2;`   `        ``// Calculate the fourth power of` `        ``// the curr and prev` `        ``ll curr = power(v[mid].first, 4);` `        ``ll prev = power(v[mid - 1].first, 4);`   `        ``if` `(curr == n) {`   `            ``// Return value of mid` `            ``return` `v[mid].second;` `        ``}`   `        ``else` `if` `(curr > n and prev <= n) {`   `            ``// Return value of mid-1` `            ``return` `v[mid - 1].second;` `        ``}` `        ``else` `if` `(curr > n) {`   `            ``// Update the value of high` `            ``high = mid - 1;` `        ``}`   `        ``else` `{`   `            ``// Update the value of low` `            ``low = mid + 1;` `        ``}` `    ``}` `    ``return` `0;` `}`   `// Driver Code` `int` `main()` `{` `    ``ll N = 100;` `    ``cout << countIntegers(N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.Vector;`   `public` `class` `GFG {` `    ``static` `int` `MAX = (``int``)1e5;`   `    ``public` `static` `class` `pair {` `        ``long` `first;` `        ``long` `second;` `        ``pair(``long` `first, ``long` `second)` `        ``{` `            ``this``.first = first;` `            ``this``.second = second;` `        ``}` `    ``}` `    ``// Function to calculate the value of` `    ``// (x^y) using binary exponentiation` `    ``static` `long` `power(``long` `x, ``long` `y)` `    ``{` `      `  `        ``// Stores the value of x^y` `        ``long` `res = ``1``;`   `        ``// Base Case` `        ``if` `(x == ``0``)` `            ``return` `0``;`   `        ``while` `(y > ``0``) ` `        ``{`   `            ``// If y is odd multiply` `            ``// x with result` `            ``if` `((y & ``1``) == ``1``)` `                ``res = (res * x);`   `            ``// Otherwise, divide y by 2` `            ``y = y >> ``1``;`   `            ``x = (x * x);` `        ``}` `        ``return` `res;` `    ``}`   `    ``// Function to perform the Sieve Of` `    ``// Eratosthenes to find the prime` `    ``// number over the range [1, 10^5]` `    ``static` `void` `SieveOfEratosthenes(Vector v)` `    ``{` `        ``boolean` `prime[] = ``new` `boolean``[MAX + ``1``];`   `        ``for` `(``int` `i = ``0``; i < prime.length; i++) {` `            ``prime[i] = ``true``;` `        ``}`   `        ``prime[``1``] = ``false``;`   `        ``for` `(``int` `p = ``2``; p * p <= MAX; p++) {`   `            ``// If prime[p] is not changed` `            ``// then it is a prime` `            ``if` `(prime[p] == ``true``) {`   `                ``// Set all the multiples of` `                ``// p to non-prime` `                ``for` `(``int` `i = p * ``2``; i <= MAX; i += p)` `                    ``prime[i] = ``false``;` `            ``}` `        ``}`   `        ``int` `num = ``1``;`   `        ``// Iterate over the range [1, MAX]` `        ``for` `(``int` `i = ``1``; i <= MAX; i++) {`   `            ``// Store all the prime number` `            ``if` `(prime[i]) {` `                ``v.add(``new` `pair(i, num));` `                ``num++;` `            ``}` `        ``}` `    ``}`   `    ``// Function to find the primes having` `    ``// only 5 divisors` `    ``static` `long` `countIntegers(``long` `n)` `    ``{` `        ``// Base Case` `        ``if` `(n < ``16``) {` `            ``return` `0``;` `        ``}`   `        ``// First value of the pair has the` `        ``// prime number and the second value` `        ``// has the count of primes till that` `        ``// prime numbers` `        ``Vector v = ``new` `Vector<>();`   `        ``// Precomputing all the primes` `        ``SieveOfEratosthenes(v);`   `        ``int` `low = ``0``;` `        ``int` `high = v.size() - ``1``;`   `        ``// Perform the Binary search` `        ``while` `(low <= high) {`   `            ``int` `mid = (low + high) / ``2``;`   `            ``// Calculate the fourth power of` `            ``// the curr and prev` `            ``long` `curr = power(v.get(mid).first, ``4``);` `            ``long` `prev = power(v.get(mid - ``1``).first, ``4``);`   `            ``if` `(curr == n) {`   `                ``// Return value of mid` `                ``return` `v.get(mid).second;` `            ``}`   `            ``else` `if` `(curr > n && prev <= n) {`   `                ``// Return value of mid-1` `                ``return` `v.get(mid - ``1``).second;` `            ``}` `            ``else` `if` `(curr > n) {`   `                ``// Update the value of high` `                ``high = mid - ``1``;` `            ``}`   `            ``else` `{`   `                ``// Update the value of low` `                ``low = mid + ``1``;` `            ``}` `        ``}` `        ``return` `0``;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``long` `N = ``100``;` `        ``System.out.println(countIntegers(N));` `    ``}` `}`   `// This code is contributed by abhinavjain194`

Output:

`2`

Time Complexity: O(N*log N)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up
Recommended Articles
Page :