# Find numbers with n-divisors in a given range

Given three integers a, b, n .Your task is to print number of numbers between a and b including them also which have n-divisors. A number is called n-divisor if it has total n divisors including 1 and itself.
Examples:

```Input  : a = 1, b = 7, n = 2
Output : 4
There are four numbers with 2 divisors in
range [1, 7]. The numbers are 2, 3, 5, and 7.
```

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Naive Approach:
The naive approach is to check all the numbers between a and b how many of them are n-divisor number for doing this find out the number of each divisors for each number . If it is equal to n then it is a n-divisor number

Efficient Approach:
Any number can be written in the form of its prime factorization let the number be x and p1, p2..pm are the prime numbers which divide x so x = p1e1 * p2e2….pmem where e1, e2…em are the exponents of prime numbers p1, p2….pm. So the number of divisors of x will be (e1+1)*(e2+1)…*(em+1).
Now the second observation is for prime numbers greater than sqrt(x) their exponent cannot exceed 1. Let’s prove this by contradiction suppose there is a prime number P greater than sqrt(x) and its exponent E in prime factorization of x is greater than one (E >= 2) so P^E sqrt(x) so P^E > (sqrt(x))E and E >= 2 so PE will always be greater than x
Third observation is that number of prime numbers greater than sqrt(x) in the prime factorization of x will always be less than equal to 1. This can also be proved similarly by contradiction as above.

Now to solve this problem
Step 1: Apply sieve of eratosthenes and calculate prime numbers upto sqrt(b).

Step 2: Traverse through each number from a to b and calculate exponents of each prime number in that number by repeatedly dividing that number by prime number and use the formula numberofdivisors(x) = (e1+1)*(e2+1)….(em+1).

Step 3: If after dividing by all the prime numbers less than equal to square root of that number if number > 1 this means there is a prime number greater than its square root which divides and its exponent will always be one as proved above.

## C++

 `// C++ program to count numbers with n divisors ` `#include ` `using` `namespace` `std; ` ` `  `// applying sieve of eratosthenes ` `void` `sieve(``bool` `primes[], ``int` `x) ` `{ ` `    ``primes = ``false``; ` ` `  `    ``// if a number is prime mark all its multiples ` `    ``// as non prime ` `    ``for` `(``int` `i=2; i*i <= x; i++) ` `    ``{ ` `        ``if` `(primes[i] == ``true``) ` `        ``{ ` `            ``for` `(``int` `j=2; j*i <= x; j++) ` `                ``primes[i*j] = ``false``; ` `        ``} ` `    ``} ` `} ` ` `  `// function that returns numbers of number that have ` `// n divisors in range from a to b. x is sqrt(b) + 1. ` `int` `nDivisors(``bool` `primes[], ``int` `x, ``int` `a, ``int` `b, ``int` `n) ` `{ ` `    ``// result holds number of numbers having n divisors ` `    ``int` `result = 0; ` ` `  `    ``// vector to hold all the prime numbers between 1 ` `    ``// ans sqrt(b) ` `    ``vector <``int``> v; ` `    ``for` `(``int` `i = 2; i <= x; i++) ` `        ``if` `(primes[i] == ``true``) ` `            ``v.push_back (i); ` ` `  `    ``// Traversing all numbers in given range ` `    ``for` `(``int` `i=a; i<=b; i++) ` `    ``{ ` `        ``// initialising temp as i ` `        ``int` `temp = i; ` ` `  `        ``// total holds the number of divisors of i ` `        ``int` `total = 1; ` `        ``int` `j = 0; ` ` `  `        ``// we need to use that prime numbers that ` `        ``// are less than equal to sqrt(temp) ` `        ``for` `(``int` `k = v[j]; k*k <= temp; k = v[++j]) ` `        ``{ ` `            ``// holds the exponent of k in prime ` `            ``// factorization of i ` `            ``int` `count = 0; ` ` `  `            ``// repeatedly divide temp by k till it is ` `            ``// divisible and accordingly increase count ` `            ``while` `(temp%k == 0) ` `            ``{ ` `                ``count++; ` `                ``temp = temp/k; ` `            ``} ` ` `  `            ``// using the formula  no.of divisors = ` `            ``// (e1+1)*(e2+1).... ` `            ``total = total*(count+1); ` `        ``} ` ` `  `        ``// if temp is not equal to 1 then there is ` `        ``// prime number in prime factorization of i ` `        ``// greater than sqrt(i) ` `        ``if` `(temp != 1) ` `            ``total = total*2; ` ` `  `        ``// if i is a ndvisor number increase result ` `        ``if` `(total == n) ` `            ``result++; ` `    ``} ` `    ``return` `result; ` `} ` ` `  `// Returns count of numbers in [a..b] having ` `// n divisors. ` `int` `countNDivisors(``int` `a, ``int` `b, ``int` `n) ` `{ ` `    ``int` `x = ``sqrt``(b) + 1; ` ` `  `    ``// primes[i] = true if i is a prime number ` `    ``bool` `primes[x]; ` ` `  `    ``// initialising each number as prime ` `    ``memset``(primes, ``true``, ``sizeof``(primes)); ` `    ``sieve(primes, x); ` ` `  `    ``return` `nDivisors(primes, x, a, b, n); ` `} ` ` `  `// driver code ` `int` `main() ` `{ ` `    ``int` `a = 1, b = 7, n = 2; ` `    ``cout << countNDivisors(a, b, n); ` `    ``return` `0; ` `} `

## Java

 `// Java program to count numbers with n divisors  ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `// applying sieve of eratosthenes  ` `static` `void` `sieve(``boolean``[] primes, ``int` `x)  ` `{  ` `    ``primes[``1``] = ``true``;  ` ` `  `    ``// if a number is prime mark all its multiples  ` `    ``// as non prime  ` `    ``for` `(``int` `i=``2``; i*i <= x; i++)  ` `    ``{  ` `        ``if` `(primes[i] == ``false``)  ` `        ``{  ` `            ``for` `(``int` `j=``2``; j*i <= x; j++)  ` `                ``primes[i*j] = ``true``;  ` `        ``}  ` `    ``}  ` `}  ` ` `  `// function that returns numbers of number that have  ` `// n divisors in range from a to b. x is sqrt(b) + 1.  ` `static` `int` `nDivisors(``boolean``[] primes, ``int` `x, ``int` `a, ``int` `b, ``int` `n)  ` `{  ` `    ``// result holds number of numbers having n divisors  ` `    ``int` `result = ``0``;  ` ` `  `    ``// vector to hold all the prime numbers between 1  ` `    ``// ans sqrt(b)  ` `    ``ArrayList v=``new` `ArrayList();  ` `    ``for` `(``int` `i = ``2``; i <= x; i++)  ` `        ``if` `(primes[i] == ``false``)  ` `            ``v.add(i);  ` `     `  `    ``// Traversing all numbers in given range  ` `    ``for` `(``int` `i=a; i<=b; i++)  ` `    ``{  ` `        ``// initialising temp as i  ` `        ``int` `temp = i;  ` ` `  `        ``// total holds the number of divisors of i  ` `        ``int` `total = ``1``;  ` `        ``int` `j = ``0``;  ` ` `  `        ``// we need to use that prime numbers that  ` `        ``// are less than equal to sqrt(temp) ` `        ``for` `(``int` `k = v.get(j); k*k <= temp; k = v.get(++j)) ` `        ``{  ` `            ``// holds the exponent of k in prime  ` `            ``// factorization of i  ` `            ``int` `count = ``0``;  ` ` `  `            ``// repeatedly divide temp by k till it is  ` `            ``// divisible and accordingly increase count  ` `            ``while` `(temp%k == ``0``)  ` `            ``{  ` `                ``count++;  ` `                ``temp = temp/k;  ` `            ``}  ` ` `  `            ``// using the formula no.of divisors =  ` `            ``// (e1+1)*(e2+1)....  ` `            ``total = total*(count+``1``); ` `             `  `        ``}  ` ` `  `        ``// if temp is not equal to 1 then there is  ` `        ``// prime number in prime factorization of i  ` `        ``// greater than sqrt(i)  ` `        ``if` `(temp != ``1``)  ` `            ``total = total*``2``;  ` ` `  `        ``// if i is a ndvisor number increase result  ` `        ``if` `(total == n)  ` `            ``result++;  ` `    ``}  ` `    ``return` `result;  ` `}  ` ` `  `// Returns count of numbers in [a..b] having  ` `// n divisors.  ` `static` `int` `countNDivisors(``int` `a, ``int` `b, ``int` `n)  ` `{  ` `    ``int` `x = (``int``)Math.sqrt(b) + ``1``;  ` ` `  `    ``// primes[i] = true if i is a prime number  ` `    ``boolean``[] primes=``new` `boolean``[x+``1``];  ` ` `  `    ``// initialising each number as prime  ` `    ``sieve(primes, x);  ` ` `  `    ``return` `nDivisors(primes, x, a, b, n);  ` `}  ` ` `  `// driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``int` `a = ``1``, b = ``7``, n = ``2``;  ` `    ``System.out.println(countNDivisors(a, b, n));  ` `  `  `}  ` `} ` `// This code is contributed by mits `

## Python3

 `# Python3 program to count numbers  ` `# with n divisors  ` `import` `math; ` ` `  `# applying sieve of eratosthenes  ` `def` `sieve(primes, x): ` `    ``primes[``1``] ``=` `False``; ` `     `  `    ``# if a number is prime mark all  ` `    ``# its multiples as non prime ` `    ``i ``=` `2``; ` `    ``while` `(i ``*` `i <``=` `x): ` `        ``if` `(primes[i] ``=``=` `True``): ` `            ``j ``=` `2``; ` `            ``while` `(j ``*` `i <``=` `x): ` `                ``primes[i ``*` `j] ``=` `False``; ` `                ``j ``+``=` `1``; ` `        ``i ``+``=` `1``; ` ` `  `# function that returns numbers of number  ` `# that have n divisors in range from a to b. ` `# x is sqrt(b) + 1.  ` `def` `nDivisors(primes, x, a, b, n): ` `     `  `    ``# result holds number of numbers ` `    ``# having n divisors  ` `    ``result ``=` `0``;  ` ` `  `    ``# vector to hold all the prime  ` `    ``# numbers between 1 and sqrt(b)  ` `    ``v ``=` `[];  ` `    ``for` `i ``in` `range``(``2``, x ``+` `1``):  ` `        ``if` `(primes[i]):  ` `            ``v.append(i);  ` ` `  `    ``# Traversing all numbers in given range  ` `    ``for` `i ``in` `range``(a, b ``+` `1``):  ` `         `  `        ``# initialising temp as i  ` `        ``temp ``=` `i;  ` ` `  `        ``# total holds the number of  ` `        ``# divisors of i  ` `        ``total ``=` `1``;  ` `        ``j ``=` `0``;  ` ` `  `        ``# we need to use that prime numbers that  ` `        ``# are less than equal to sqrt(temp) ` `        ``k ``=` `v[j]; ` `        ``while` `(k ``*` `k <``=` `temp): ` `             `  `            ``# holds the exponent of k in prime  ` `            ``# factorization of i  ` `            ``count ``=` `0``;  ` ` `  `            ``# repeatedly divide temp by k till it is  ` `            ``# divisible and accordingly increase count  ` `            ``while` `(temp ``%` `k ``=``=` `0``): ` `                ``count ``+``=` `1``;  ` `                ``temp ``=` `int``(temp ``/` `k);  ` ` `  `            ``# using the formula no.of divisors =  ` `            ``# (e1+1)*(e2+1)....  ` `            ``total ``=` `total ``*` `(count ``+` `1``); ` `            ``j ``+``=` `1``; ` `            ``k ``=` `v[j]; ` ` `  `        ``# if temp is not equal to 1 then there is  ` `        ``# prime number in prime factorization of i  ` `        ``# greater than sqrt(i)  ` `        ``if` `(temp !``=` `1``):  ` `            ``total ``=` `total ``*` `2``;  ` ` `  `        ``# if i is a ndivisor number  ` `        ``# increase result  ` `        ``if` `(total ``=``=` `n):  ` `            ``result ``+``=` `1``;  ` `    ``return` `result;  ` ` `  `# Returns count of numbers in [a..b]  ` `# having n divisors.  ` `def` `countNDivisors(a, b, n):  ` `    ``x ``=` `int``(math.sqrt(b) ``+` `1``);  ` ` `  `    ``# primes[i] = true if i is a prime number  ` `    ``# initialising each number as prime  ` `    ``primes ``=` `[``True``] ``*` `(x ``+` `1``); ` `    ``sieve(primes, x);  ` ` `  `    ``return` `nDivisors(primes, x, a, b, n);  ` ` `  `# Driver code  ` `a ``=` `1``; ` `b ``=` `7``; ` `n ``=` `2``;  ` `print``(countNDivisors(a, b, n));  ` ` `  `# This code is contributed by mits `

## C#

 `// C# program to count numbers with n divisors  ` `using` `System.Collections; ` `using` `System; ` `class` `GFG{ ` `// applying sieve of eratosthenes  ` `static` `void` `sieve(``bool``[] primes, ``int` `x)  ` `{  ` `    ``primes = ``true``;  ` ` `  `    ``// if a number is prime mark all its multiples  ` `    ``// as non prime  ` `    ``for` `(``int` `i=2; i*i <= x; i++)  ` `    ``{  ` `        ``if` `(primes[i] == ``false``)  ` `        ``{  ` `            ``for` `(``int` `j=2; j*i <= x; j++)  ` `                ``primes[i*j] = ``true``;  ` `        ``}  ` `    ``}  ` `}  ` ` `  `// function that returns numbers of number that have  ` `// n divisors in range from a to b. x is sqrt(b) + 1.  ` `static` `int` `nDivisors(``bool``[] primes, ``int` `x, ``int` `a, ``int` `b, ``int` `n)  ` `{  ` `    ``// result holds number of numbers having n divisors  ` `    ``int` `result = 0;  ` ` `  `    ``// vector to hold all the prime numbers between 1  ` `    ``// ans sqrt(b)  ` `    ``ArrayList v=``new` `ArrayList();  ` `    ``for` `(``int` `i = 2; i <= x; i++)  ` `        ``if` `(primes[i] == ``false``)  ` `            ``v.Add(i);  ` `     `  `    ``// Traversing all numbers in given range  ` `    ``for` `(``int` `i=a; i<=b; i++)  ` `    ``{  ` `        ``// initialising temp as i  ` `        ``int` `temp = i;  ` ` `  `        ``// total holds the number of divisors of i  ` `        ``int` `total = 1;  ` `        ``int` `j = 0;  ` ` `  `        ``// we need to use that prime numbers that  ` `        ``// are less than equal to sqrt(temp) ` `        ``for` `(``int` `k = (``int``)v[j]; k*k <= temp; k = (``int``)v[++j]) ` `        ``{  ` `            ``// holds the exponent of k in prime  ` `            ``// factorization of i  ` `            ``int` `count = 0;  ` ` `  `            ``// repeatedly divide temp by k till it is  ` `            ``// divisible and accordingly increase count  ` `            ``while` `(temp%k == 0)  ` `            ``{  ` `                ``count++;  ` `                ``temp = temp/k;  ` `            ``}  ` ` `  `            ``// using the formula no.of divisors =  ` `            ``// (e1+1)*(e2+1)....  ` `            ``total = total*(count+1); ` `             `  `        ``}  ` ` `  `        ``// if temp is not equal to 1 then there is  ` `        ``// prime number in prime factorization of i  ` `        ``// greater than sqrt(i)  ` `        ``if` `(temp != 1)  ` `            ``total = total*2;  ` ` `  `        ``// if i is a ndivisor number increase result  ` `        ``if` `(total == n)  ` `            ``result++;  ` `    ``}  ` `    ``return` `result;  ` `}  ` ` `  `// Returns count of numbers in [a..b] having  ` `// n divisors.  ` `static` `int` `countNDivisors(``int` `a, ``int` `b, ``int` `n)  ` `{  ` `    ``int` `x = (``int``)Math.Sqrt(b) + 1;  ` ` `  `    ``// primes[i] = true if i is a prime number  ` `    ``bool``[] primes=``new` `bool``[x+1];  ` ` `  `    ``// initialising each number as prime  ` `    ``sieve(primes, x);  ` ` `  `    ``return` `nDivisors(primes, x, a, b, n);  ` `}  ` ` `  `// driver code  ` `public` `static` `void` `Main()  ` `{  ` `    ``int` `a = 1, b = 7, n = 2;  ` `    ``Console.WriteLine(countNDivisors(a, b, n));  ` `  `  `}  ` `} ` `// This code is contributed by mits `

## PHP

 ` `

Output:

```4
```

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