# Count number of integers less than or equal to N which has exactly 9 divisors

• Difficulty Level : Hard
• Last Updated : 13 Jun, 2022

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:
The two numbers which have exactly 9 divisors are 36 and 100.
Input: N = 1000
Output:
The numbers are 36 100 196 225 256 441 484 676

A naive approach is to iterate for all numbers till N and count the numbers that have exactly 9 divisors. For counting the 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 the 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

 ``

## Javascript

 ``

Output:

`8`

Time Complexity: O(N2), as we are using a loop to traverse N times and in each traversal we are calling the function numberofDivisors which will cost O (N) in worst case, hence the complexity of the program will be O(N*N).

Auxiliary Space: O(1), as we are not using any extra space.

An efficient approach is to use the property of the prime factor 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 the 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 the count of numbers that can be expressed in the 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

 ``

## Javascript

 ``

Output:

`8`

Time Complexity: O(N), as we are using nested loops where the outer loop traverses sqrt(N) times and the inner loop also traverses sqrt(N) time in the worst case so the effective time complexity of the program will be O(N)
Auxiliary Space: O(sqrt(N)), as we are using extra space for the prime array.

My Personal Notes arrow_drop_up
Recommended Articles
Page :