Related Articles
Count number of integers less than or equal to N which has exactly 9 divisors
• Difficulty Level : Medium
• Last Updated : 21 Nov, 2019

Given a number N(1<=N<=109), the task is to find the total number of integers less than equal to n which have exactly 9 divisors.

Examples:

Input: N = 100
Output: 2
The two numbers which have exactly 9 divisors are 36 and 100.

Input: N = 1000
Output: 8
The numbers are 36 100 196 225 256 441 484 676

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A naive approach is to iterate for all numbers till N and count the numbers that have exactly 9 divisors. For counting number of divisors, one can easily iterate till N and check if N is divisible by i or not and keep a count.
Below is the implementation of above approach:

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;`` ` `// Function to count factors in O(N)``int` `numberOfDivisors(``int` `num)``{``    ``int` `c = 0;`` ` `    ``// iterate and check if factor or not``    ``for` `(``int` `i = 1; i <= num; i++) {``        ``if` `(num % i == 0) {``            ``c += 1;``        ``}``    ``}``    ``return` `c;``}`` ` `// Function to count numbers having``// exactly 9 divisors``int` `countNumbers(``int` `n)``{``    ``int` `c = 0;`` ` `    ``// check for all numbers <=N``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``// check if exactly 9 factors or not``        ``if` `(numberOfDivisors(i) == 9)``            ``c += 1;``    ``}``    ``return` `c;``}`` ` `// Driver Code``int` `main()``{``    ``int` `n = 1000;`` ` `    ``cout << countNumbers(n);`` ` `return` `0;``}`

## Java

 `// Java implementation of above approach`` ` `import` `java.io.*;`` ` `class` `GFG {`` ` `// Function to count factors in O(N)``static` `int` `numberOfDivisors(``int` `num)``{``    ``int` `c = ``0``;`` ` `    ``// iterate and check if factor or not``    ``for` `(``int` `i = ``1``; i <= num; i++) {``        ``if` `(num % i == ``0``) {``            ``c += ``1``;``        ``}``    ``}``    ``return` `c;``}`` ` `// Function to count numbers having``// exactly 9 divisors``static` `int` `countNumbers(``int` `n)``{``    ``int` `c = ``0``;`` ` `    ``// check for all numbers <=N``    ``for` `(``int` `i = ``1``; i <= n; i++) {``        ``// check if exactly 9 factors or not``        ``if` `(numberOfDivisors(i) == ``9``)``            ``c += ``1``;``    ``}``    ``return` `c;``}`` ` `       ``// Driver Code``    ``public` `static` `void` `main (String[] args) {``    ``int` `n = ``1000``;`` ` `    ``System.out.print(countNumbers(n));``    ``}``}`` ` `// This code is contributed by inder_verma..`

## Python 3

 `# Python 3 implementation of``# above approach`` ` `# Function to count factors in O(N)``def` `numberOfDivisors(num):``    ``c ``=` `0`` ` `    ``# iterate and check if ``    ``# factor or not``    ``for` `i ``in` `range``(``1``, num ``+` `1``) :``        ``if` `(num ``%` `i ``=``=` `0``) :``            ``c ``+``=` `1``         ` `    ``return` `c`` ` `# Function to count numbers having``# exactly 9 divisors``def` `countNumbers(n):`` ` `    ``c ``=` `0`` ` `    ``# check for all numbers <=N``    ``for` `i ``in` `range``(``1``, n ``+` `1``) :``         ` `        ``# check if exactly 9 factors or not``        ``if` `(numberOfDivisors(i) ``=``=` `9``):``            ``c ``+``=` `1``    ``return` `c`` ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``n ``=` `1000`` ` `    ``print``(countNumbers(n))`` ` `# This code is contributed``# by ChitraNayal`

## C#

 `// C# implementation of above approach``using` `System;`` ` `class` `GFG ``{`` ` `// Function to count factors in O(N)``static` `int` `numberOfDivisors(``int` `num)``{``    ``int` `c = 0;`` ` `    ``// iterate and check if factor or not``    ``for` `(``int` `i = 1; i <= num; i++) ``    ``{``        ``if` `(num % i == 0) ``        ``{``            ``c += 1;``        ``}``    ``}``    ``return` `c;``}`` ` `// Function to count numbers having``// exactly 9 divisors``static` `int` `countNumbers(``int` `n)``{``    ``int` `c = 0;`` ` `    ``// check for all numbers <=N``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``// check if exactly 9 factors or not``        ``if` `(numberOfDivisors(i) == 9)``            ``c += 1;``    ``}``    ``return` `c;``}`` ` `// Driver Code``public` `static` `void` `Main ()``{``int` `n = 1000;`` ` `Console.Write(countNumbers(n));``}``}`` ` `// This code is contributed ``// by Akanksha Rai(Abby_akku) `

## PHP

 ``
Output:
```8
```

An efficient approach is to use the prime factors property to count the number of divisors of a number. The method can be found here. If any number(let x) can be expressed in terms of (p^2 * q^2) or (p^8), where p and q are prime factors of X, then X has a total of 9 divisors. The below steps can be followed to solve the above problem.

1. Use Sieve technique to mark the smallest prime factor of a number.
2. We just need to check for all the numbers in range[1-sqrt(n)] that can be expressed in terms of p*q since (p^2*q^2) has 9 factors, hence (p*q)^2 will also have exactly 9 factors.
3. Iterate from 1 to sqrt(n) and check if i can be expressed as p*q, where p and q are prime numbers.
4. Also check if i is prime then pow(i, 8)<=n or not, in that case count that number also.
5. The summation of count of numbers that can be expressed in form p*q and p^8 is our answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;`` ` `// Function to count numbers having``// exactly 9 divisors``int` `countNumbers(``int` `n)``{``    ``int` `c = 0;`` ` `    ``int` `limit = ``sqrt``(n);`` ` `    ``// Sieve array``    ``int` `prime[limit + 1];`` ` `    ``// initially prime[i] = i``    ``for` `(``int` `i = 1; i <= limit; i++)``        ``prime[i] = i;`` ` `    ``// use sieve concept to store the``    ``// first prime factor of every number``    ``for` `(``int` `i = 2; i * i <= limit; i++) {``        ``if` `(prime[i] == i) {``            ``// mark all factors of i``            ``for` `(``int` `j = i * i; j <= limit; j += i)``                ``if` `(prime[j] == j)``                    ``prime[j] = i;``        ``}``    ``}`` ` `    ``// check for all numbers if they can be``    ``// expressed in form p*q``    ``for` `(``int` `i = 2; i <= limit; i++) {``        ``// p prime factor``        ``int` `p = prime[i];`` ` `        ``// q prime factor``        ``int` `q = prime[i / prime[i]];`` ` `        ``// if both prime factors are different``        ``// if p*q<=n and q!=``        ``if` `(p * q == i && q != 1 && p != q) {``            ``c += 1;``        ``}``        ``else` `if` `(prime[i] == i) {`` ` `            ``// Check if it can be expressed as p^8``            ``if` `(``pow``(i, 8) <= n) {`` ` `                ``c += 1;``            ``}``        ``}``    ``}`` ` `    ``return` `c;``}`` ` `// Driver Code``int` `main()``{``    ``int` `n = 1000;`` ` `    ``cout << countNumbers(n);`` ` `return` `0;``}`

## Java

 `// Java implementation of above approach``public` `class` `GFG {`` ` `// Function to count numbers having``// exactly 9 divisors``    ``static` `int` `countNumbers(``int` `n) {``        ``int` `c = ``0``;`` ` `        ``int` `limit = (``int``) Math.sqrt(n);`` ` `        ``// Sieve array``        ``int` `prime[] = ``new` `int``[limit + ``1``];`` ` `        ``// initially prime[i] = i``        ``for` `(``int` `i = ``1``; i <= limit; i++) {``            ``prime[i] = i;``        ``}`` ` `        ``// use sieve concept to store the``        ``// first prime factor of every number``        ``for` `(``int` `i = ``2``; i * i <= limit; i++) {``            ``if` `(prime[i] == i) {``                ``// mark all factors of i``                ``for` `(``int` `j = i * i; j <= limit; j += i) {``                    ``if` `(prime[j] == j) {``                        ``prime[j] = i;``                    ``}``                ``}``            ``}``        ``}`` ` `        ``// check for all numbers if they can be``        ``// expressed in form p*q``        ``for` `(``int` `i = ``2``; i <= limit; i++) {``            ``// p prime factor``            ``int` `p = prime[i];`` ` `            ``// q prime factor``            ``int` `q = prime[i / prime[i]];`` ` `            ``// if both prime factors are different``            ``// if p*q<=n and q!=``            ``if` `(p * q == i && q != ``1` `&& p != q) {``                ``c += ``1``;``            ``} ``else` `if` `(prime[i] == i) {`` ` `                ``// Check if it can be expressed as p^8``                ``if` `(Math.pow(i, ``8``) <= n) {`` ` `                    ``c += ``1``;``                ``}``            ``}``        ``}`` ` `        ``return` `c;``    ``}`` ` `// Driver Code``    ``public` `static` `void` `main(String[] args) {``        ``int` `n = ``1000``;`` ` `        ``System.out.println(countNumbers(n));`` ` `    ``}``}``/*This code is contributed by PrinciRaj1992*/`

## Python3

 `# Python3 implementation of the above approach `` ` `# Function to count numbers ``# having exactly 9 divisors ``def` `countNumbers(n): ``     ` `    ``c ``=` `0``    ``limit ``=` `int``(n ``*``*` `(``0.5``))`` ` `    ``# Sieve array, initially prime[i] = i ``    ``prime ``=` `[i ``for` `i ``in` `range``(limit ``+` `1``)] ``     ` `    ``# use sieve concept to store the ``    ``# first prime factor of every number ``    ``i ``=` `2``    ``while` `i ``*` `i <``=` `limit: ``        ``if` `prime[i] ``=``=` `i: ``             ` `            ``# mark all factors of i ``            ``for` `j ``in` `range``(i ``*` `i, limit ``+` `1``, i): ``                ``if` `prime[j] ``=``=` `j: ``                    ``prime[j] ``=` `i ``         ` `        ``i ``+``=` `1`` ` `    ``# check for all numbers if they ``    ``# can be expressed in form p*q ``    ``for` `i ``in` `range``(``2``, limit ``+` `1``): ``         ` `        ``# p prime factor ``        ``p ``=` `prime[i] `` ` `        ``# q prime factor ``        ``q ``=` `prime[i ``/``/` `prime[i]] `` ` `        ``# if both prime factors are different ``        ``# if p*q<=n and q!= ``        ``if` `p ``*` `q ``=``=` `i ``and` `q !``=` `1` `and` `p !``=` `q: ``            ``c ``+``=` `1``         ` `        ``elif` `prime[i] ``=``=` `i: `` ` `            ``# Check if it can be ``            ``# expressed as p^8 ``            ``if` `i ``*``*` `8` `<``=` `n: ``                ``c ``+``=` `1``     ` `    ``return` `c `` ` `# Driver Code ``if` `__name__ ``=``=` `"__main__"``: `` ` `    ``n ``=` `1000``    ``print``(countNumbers(n)) `` ` `# This code is contributed``# by Rituraj Jain`

## C#

 `// C# implementation of above approach``using` `System; `` ` `public` `class` `GFG { `` ` `// Function to count numbers having``// exactly 9 divisors``    ``static` `int` `countNumbers(``int` `n) {``        ``int` `c = 0;``  ` `        ``int` `limit = (``int``) Math.Sqrt(n);``  ` `        ``// Sieve array``        ``int` `[]prime = ``new` `int``[limit + 1];``  ` `        ``// initially prime[i] = i``        ``for` `(``int` `i = 1; i <= limit; i++) {``            ``prime[i] = i;``        ``}``  ` `        ``// use sieve concept to store the``        ``// first prime factor of every number``        ``for` `(``int` `i = 2; i * i <= limit; i++) {``            ``if` `(prime[i] == i) {``                ``// mark all factors of i``                ``for` `(``int` `j = i * i; j <= limit; j += i) {``                    ``if` `(prime[j] == j) {``                        ``prime[j] = i;``                    ``}``                ``}``            ``}``        ``}``  ` `        ``// check for all numbers if they can be``        ``// expressed in form p*q``        ``for` `(``int` `i = 2; i <= limit; i++) {``            ``// p prime factor``            ``int` `p = prime[i];``  ` `            ``// q prime factor``            ``int` `q = prime[i / prime[i]];``  ` `            ``// if both prime factors are different``            ``// if p*q<=n and q!=``            ``if` `(p * q == i && q != 1 && p != q) {``                ``c += 1;``            ``} ``else` `if` `(prime[i] == i) {``  ` `                ``// Check if it can be expressed as p^8``                ``if` `(Math.Pow(i, 8) <= n) {``  ` `                    ``c += 1;``                ``}``            ``}``        ``}``  ` `        ``return` `c;``    ``}``  ` `// Driver Code``    ``public` `static` `void` `Main() {``        ``int` `n = 1000;``  ` `        ``Console.WriteLine(countNumbers(n));``  ` `    ``}``}``/*This code is contributed by PrinciRaj1992*/`

## PHP

 ``
Output:
```8
```

Time Complexity: O(sqrt(N))
Auxiliary Space: O(sqrt(N)) My Personal Notes arrow_drop_up