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

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

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:



filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above approach
#include <bits/stdc++.h>
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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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..
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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) 
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of above approach
  
// Function to count factors in O(N)
Function numberOfDivisors($num)
{
    $c = 0;
  
    // iterate and check 
    // if factor or not
    for ($i = 1; $i <= $num; $i++) {
          
        if ($num % $i == 0) {
            $c += 1;
        }
    }
    return $c;
}
  
// Function to count numbers
// having exactly 9 divisors
Function countNumbers($n)
{
    $c = 0;
  
    // check for all numbers <=N
    for ($i = 1; $i <= $n; $i++) {
          
        // check if exactly 9 factors or not
        if (numberOfDivisors($i) == 9)
            $c += 1;
    }
    return $c;
}
  
// Driver Code
$n = 1000;
  
echo countNumbers($n);
  
// This code is contributed
// by Shivi_Aggarwal
?>
chevron_right

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:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above approach
#include <bits/stdc++.h>
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;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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*/
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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 += 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
  
# Driver Code 
if __name__ == "__main__"
  
    n = 1000
    print(countNumbers(n)) 
  
# This code is contributed
# by Rituraj Jain
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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*/
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP implementation of above approach 
// Function to count numbers having 
// exactly 9 divisors 
  
function countNumbers($n
    $c = 0; 
    $limit = sqrt($n); 
  
    // Sieve array 
    $prime[$limit + 1] = array(0); 
  
    // initially prime[i] = i 
    for ($i = 1; $i <= $limit; $i++) 
        $prime[$i] = $i
  
    // use sieve concept to store the 
    // first prime factor of every number 
    for ($i = 2; $i * $i <= $limit; $i++) 
    
        if ($prime[$i] == $i
        
            // mark all factors of i 
            for ($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 ($i = 2; $i <= $limit; $i++) 
    
        // 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 && $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 
$n = 1000; 
echo countNumbers($n); 
  
// This code is contributed by jit_t
?>
chevron_right

Output:
8

Time Complexity: O(sqrt(N))
Auxiliary Space: O(sqrt(N))




Recommended Posts:


Striver(underscore)79 at Codechef and codeforces D

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Article Tags :