Count numbers in a given range whose count of prime factors is a Prime Number - GeeksforGeeks

17 May, 2021
Given a 2D array Q[][] of size N * 2 representing queries of the form {L, R}. For each query, the task is to print the count of numbers in the range [L, R] with a count of prime factors equal to a prime number.
Examples:
Input: Q[][] = {{4, 8}, {30, 32}} Output: 3 2 Explanation: Query 1: Prime factors of 4 = {2, 2} and count of prime factors = 2 Prime factors of 5 = {5} and count of prime factors = 1 Prime factors of 6 = {2, 3} and count of prime factors = 2 Prime factors of 7 = {7} and count of prime factors = 1 Prime factors of 8 = {2, 2, 2} and count of prime factors = 3 Therefore, the total count of numbers in the range [4, 8] having count of prime factors is a prime number is 3. Query 2: Prime factors of 30 = {2, 3, 5} and count of prime factors = 3 Prime factors of 31 = {31} and count of prime factors = 1 Prime factors of 32 = {2, 2, 2, 2, 2} and count of prime factors = 5 Therefore, the total count of numbers in the range [4, 8] having count of prime factors is a prime number is 2.
Input: Q[][] = {{7, 12}, {10, 99}} Output: 4
Naive Approach: The simplest approach to solve this problem is to traverse all the numbers in the range [L, R], and for each number, check if the count of prime factors of the number is a prime number or not. If found to be true, increment the counter by 1. After traversing, print the value of counter for each query. 
Time Complexity: O(|Q| * (max(arr[i][1] – arr[i][0] + 1)) * sqrt(max(arr[i][1])) Auxiliary space: O (1)
Efficient Approach: To optimize the above approach the idea is to precompute the smallest prime factor of each number in the range [Li, Ri] using Sieve of Eratosthenes. Follow the steps below to solve the problem:
Generate and store the smallest prime factor of each element using Sieve of Eratosthenes.
Find the count of prime factors for each number in the range [Li, Ri] using the Sieve.
For each number, check if the total count of prime factors is a prime number or not. If found to be true then increment the counter.
Create a prefix sum array, say sum[], where sum[i] will store the sum of elements from the range [0, i] whose count of prime factors is a prime number.
Finally, for each query, print the value sum[arr[i][1]] – sum[arr[i][0] – 1].
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program to implement// the above approach#include <bits/stdc++.h>using namespace std;#define MAX 1001 // Function to find the smallest prime factor// of all the numbers in range [0, MAX]vector<int> sieve(){     // Stores smallest prime factor of all    // the numbers in the range [0, MAX]    vector<int> spf(MAX);     // No smallest prime factor of    // 0 and 1 exists    spf[0] = spf[1] = -1;     // Traverse all the numbers    // in the range [1, MAX]    for (int i = 2; i < MAX; i++) {         // Update spf[i]        spf[i] = i;    }     // Update all the numbers whose    // smallest prime factor is 2    for (int i = 4; i < MAX; i = i + 2) {        spf[i] = 2;    }     // Traverse all the numbers in    // the range [1, sqrt(MAX)]    for (int i = 3; i * i < MAX; i++) {         // Check if i is a prime number        if (spf[i] == i) {             // Update all the numbers whose            // smallest prime factor is i            for (int j = i * i; j < MAX;                 j = j + i) {                 // Check if j is                // a prime number                if (spf[j] == j) {                    spf[j] = i;                }            }        }    }    return spf;} // Function to find count of// prime factor of numint countFactors(vector<int>& spf, int num){    // Stores count of    // prime factor of num    int count = 0;     // Calculate count of    // prime factor    while (num > 1) {         // Update count        count++;         // Update num        num = num / spf[num];    }    return count;} // Function to precalculate the count of// numbers in the range [0, i] whose count// of prime factors is a prime numbervector<int> precalculateSum(vector<int>& spf){     // Stores the sum of all the numbers    // in the range[0, i] count of    // prime factor is a prime number    vector<int> sum(MAX);     // Update sum[0]    sum[0] = 0;     // Traverse all the numbers in    // the range [1, MAX]    for (int i = 1; i < MAX; i++) {         // Stores count of prime factor of i        int prime_factor            = countFactors(spf, i);         // If count of prime factor is        // a prime number        if (spf[prime_factor] == prime_factor) {             // Update sum[i]            sum[i] = sum[i - 1] + 1;        }        else {             // Update sum[i]            sum[i] = sum[i - 1];        }    }    return sum;} // Driver Codeint main(){    // Stores smallest prime factor of all    // the numbers in the range [0, MAX]    vector<int> spf = sieve();     // Stores the sum of all the numbers    // in the range[0, i] count of    // prime factor is a prime number    vector<int> sum = precalculateSum(spf);     int Q[][2] = { { 4, 8 }, { 30, 32 } };     // int N = sizeof(Q) / sizeof(Q[0]);    for (int i = 0; i < 2; i++) {        cout << (sum[Q[i][1]] - sum[Q[i][0] - 1])             << " ";    }     return 0;}
// Java program to implement// the above approachimport java.util.*; class GFG{     public static int MAX = 1001; // Function to find the smallest prime factor// of all the numbers in range [0, MAX]public static int[] sieve(){         // Stores smallest prime factor of all    // the numbers in the range [0, MAX]    int spf[] = new int[MAX];       // No smallest prime factor of    // 0 and 1 exists    spf[0] = spf[1] = -1;       // Traverse all the numbers    // in the range [1, MAX]    for(int i = 2; i < MAX; i++)    {                 // Update spf[i]        spf[i] = i;    }       // Update all the numbers whose    // smallest prime factor is 2    for(int i = 4; i < MAX; i = i + 2)    {        spf[i] = 2;    }       // Traverse all the numbers in    // the range [1, sqrt(MAX)]    for(int i = 3; i * i < MAX; i++)    {                 // Check if i is a prime number        if (spf[i] == i)        {                         // Update all the numbers whose            // smallest prime factor is i            for(int j = i * i; j < MAX; j = j + i)            {                                 // Check if j is                // a prime number                if (spf[j] == j)                {                    spf[j] = i;                }            }        }    }    return spf;}   // Function to find count of// prime factor of numpublic static int countFactors(int spf[], int num){         // Stores count of    // prime factor of num    int count = 0;       // Calculate count of    // prime factor    while (num > 1)    {                 // Update count        count++;           // Update num        num = num / spf[num];    }    return count;}   // Function to precalculate the count of// numbers in the range [0, i] whose count// of prime factors is a prime numberpublic static int[] precalculateSum(int spf[]){         // Stores the sum of all the numbers    // in the range[0, i] count of    // prime factor is a prime number    int sum[] = new int[MAX];       // Update sum[0]    sum[0] = 0;       // Traverse all the numbers in    // the range [1, MAX]    for(int i = 1; i < MAX; i++)    {                 // Stores count of prime factor of i        int prime_factor = countFactors(spf, i);           // If count of prime factor is        // a prime number        if (spf[prime_factor] == prime_factor)        {                         // Update sum[i]            sum[i] = sum[i - 1] + 1;        }        else        {                         // Update sum[i]            sum[i] = sum[i - 1];        }    }    return sum;}   // Driver codepublic static void main(String[] args){         // Stores smallest prime factor of all    // the numbers in the range [0, MAX]    int spf[] = sieve();       // Stores the sum of all the numbers    // in the range[0, i] count of    // prime factor is a prime number    int sum[] = precalculateSum(spf);       int Q[][] = { { 4, 8 }, { 30, 32 } };       // int N = sizeof(Q) / sizeof(Q[0]);    for(int i = 0; i < 2; i++)    {        System.out.print((sum[Q[i][1]] -                          sum[Q[i][0] - 1]) + " ");    }}} // This code is contributed by divyeshrabadiya07
# Python3 program to implement# the above approachMAX = 1001 # Function to find the smallest# prime factor of all the numbers# in range [0, MAX]def sieve():         # Stores smallest prime factor of all    # the numbers in the range [0, MAX]    global MAX    spf = [0] * MAX         # No smallest prime factor of    # 0 and 1 exists    spf[0] = spf[1] = -1         # Traverse all the numbers    # in the range [1, MAX]    for i in range(2, MAX):                 # Update spf[i]        spf[i] = i     # Update all the numbers whose    # smallest prime factor is 2    for i in range(4, MAX, 2):        spf[i] = 2     # Traverse all the numbers in    # the range [1, sqrt(MAX)]    for i in range(3, MAX):         # Check if i is a prime number        if (spf[i] == i):             # Update all the numbers whose            # smallest prime factor is i            for j in range(i * i, MAX):                                 # Check if j is                # a prime number                if (spf[j] == j):                    spf[j] = i     return spf # Function to find count of# prime factor of numdef countFactors(spf, num):         # Stores count of    # prime factor of num    count = 0     # Calculate count of    # prime factor    while (num > 1):                 # Update count        count += 1         # Update num        num = num // spf[num]     return count # Function to precalculate the count of# numbers in the range [0, i] whose count# of prime factors is a prime numberdef precalculateSum(spf):         # Stores the sum of all the numbers    # in the range[0, i] count of    # prime factor is a prime number    sum = [0] * MAX     # Traverse all the numbers in    # the range [1, MAX]    for i in range(1, MAX):                 # Stores count of prime factor of i        prime_factor = countFactors(spf, i)         # If count of prime factor is        # a prime number        if (spf[prime_factor] == prime_factor):             # Update sum[i]            sum[i] = sum[i - 1] + 1        else:             # Update sum[i]            sum[i] = sum[i - 1]                 return sum # Driver codeif __name__ == '__main__':     # Stores smallest prime factor of all    # the numbers in the range [0, MAX]    spf = sieve()     # Stores the sum of all the numbers    # in the range[0, i] count of    # prime factor is a prime number    sum = precalculateSum(spf)     Q = [ [ 4, 8 ], [ 30, 32 ] ]    sum[Q[0][1]] += 1         # N = sizeof(Q) / sizeof(Q[0]);    for i in range(0, 2):        print((sum[Q[i][1]] -               sum[Q[i][0]]), end = " ") # This code is contributed by Princi Singh
// C# program to implement// the above approachusing System;class GFG{     public static int MAX = 1001; // Function to find the smallest// prime factor of all the numbers// in range [0, MAX]public static int[] sieve(){      // Stores smallest prime factor  // of all the numbers in the  // range [0, MAX]  int []spf = new int[MAX];   // No smallest prime factor  // of 0 and 1 exists  spf[0] = spf[1] = -1;   // Traverse all the numbers  // in the range [1, MAX]  for(int i = 2; i < MAX; i++)  {    // Update spf[i]    spf[i] = i;  }   // Update all the numbers whose  // smallest prime factor is 2  for(int i = 4; i < MAX; i = i + 2)  {    spf[i] = 2;  }   // Traverse all the numbers in  // the range [1, sqrt(MAX)]  for(int i = 3; i * i < MAX; i++)  {    // Check if i is a prime number    if (spf[i] == i)    {      // Update all the numbers      // whose smallest prime      // factor is i      for(int j = i * i;              j < MAX; j = j + i)      {        // Check if j is        // a prime number        if (spf[j] == j)        {          spf[j] = i;        }      }    }  }  return spf;}   // Function to find count of// prime factor of numpublic static int countFactors(int []spf,                               int num){      // Stores count of  // prime factor of num  int count = 0;   // Calculate count of  // prime factor  while (num > 1)  {    // Update count    count++;     // Update num    num = num / spf[num];  }  return count;}   // Function to precalculate the count of// numbers in the range [0, i] whose count// of prime factors is a prime numberpublic static int[] precalculateSum(int []spf){      // Stores the sum of all the numbers  // in the range[0, i] count of  // prime factor is a prime number  int []sum = new int[MAX];   // Update sum[0]  sum[0] = 0;   // Traverse all the numbers in  // the range [1, MAX]  for(int i = 1; i < MAX; i++)  {     // Stores count of prime factor of i    int prime_factor = countFactors(spf, i);     // If count of prime factor is    // a prime number    if (spf[prime_factor] == prime_factor)    {       // Update sum[i]      sum[i] = sum[i - 1] + 1;    }    else    {       // Update sum[i]      sum[i] = sum[i - 1];    }  }  return sum;}   // Driver codepublic static void Main(String[] args){  // Stores smallest prime factor  // of all the numbers in the  // range [0, MAX]  int []spf = sieve();   // Stores the sum of all the  // numbers in the range[0, i]  // count of prime factor is a  // prime number  int []sum = precalculateSum(spf);   int [,]Q = {{4, 8}, {30, 32}};   // int N = sizeof(Q) / sizeof(Q[0]);  for(int i = 0; i < 2; i++)  {    Console.Write((sum[Q[i, 1]] -                   sum[Q[i, 0] - 1]) +                   " ");  }}} // This code is contributed by shikhasingrajput
<script> // Javascript program to implement// the above approach let MAX = 1001 // Function to find the smallest prime factor// of all the numbers in range [0, MAX]function sieve(){     // Stores smallest prime factor of all    // the numbers in the range [0, MAX]    let spf = new Array(MAX);     // No smallest prime factor of    // 0 and 1 exists    spf[0] = spf[1] = -1;     // Traverse all the numbers    // in the range [1, MAX]    for (let i = 2; i < MAX; i++) {         // Update spf[i]        spf[i] = i;    }     // Update all the numbers whose    // smallest prime factor is 2    for (let i = 4; i < MAX; i = i + 2) {        spf[i] = 2;    }     // Traverse all the numbers in    // the range [1, sqrt(MAX)]    for (let i = 3; i * i < MAX; i++) {         // Check if i is a prime number        if (spf[i] == i) {             // Update all the numbers whose            // smallest prime factor is i            for (let j = i * i; j < MAX;                 j = j + i) {                 // Check if j is                // a prime number                if (spf[j] == j) {                    spf[j] = i;                }            }        }    }    return spf;} // Function to find count of// prime factor of numfunction countFactors(spf, num){    // Stores count of    // prime factor of num    let count = 0;     // Calculate count of    // prime factor    while (num > 1) {         // Update count        count++;         // Update num        num = num / spf[num];    }    return count;} // Function to precalculate the count of// numbers in the range [0, i] whose count// of prime factors is a prime numberfunction precalculateSum(spf){     // Stores the sum of all the numbers    // in the range[0, i] count of    // prime factor is a prime number    let sum = new Array(MAX);     // Update sum[0]    sum[0] = 0;     // Traverse all the numbers in    // the range [1, MAX]    for (let i = 1; i < MAX; i++) {         // Stores count of prime factor of i        let prime_factor            = countFactors(spf, i);         // If count of prime factor is        // a prime number        if (spf[prime_factor] == prime_factor) {             // Update sum[i]            sum[i] = sum[i - 1] + 1;        }        else {             // Update sum[i]            sum[i] = sum[i - 1];        }    }    return sum;} // Driver Code     // Stores smallest prime factor of all    // the numbers in the range [0, MAX]    let spf = sieve();     // Stores the sum of all the numbers    // in the range[0, i] count of    // prime factor is a prime number    let sum = precalculateSum(spf);     let Q = [ [ 4, 8 ], [ 30, 32 ] ];     // let N = sizeof(Q) / sizeof(Q[0]);    for (let i = 0; i < 2; i++) {        document.write((sum[Q[i][1]] - sum[Q[i][0] - 1]) +        " ");    } // This code is contributed by gfgking </script>
3 2
 
Time Complexity: O(|Q| + (MAX *log(log(MAX))))Auxiliary Space: O(MAX)
divyeshrabadiya07
shikhasingrajput
princi singh
gfgking
array-range-queries
Prime Number
prime-factor
sieve
Mathematical
Searching
Searching
Mathematical
Prime Number
sieve
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Modulo Operator (%) in C/C++ with Examples
Merge two sorted arrays
Program to find sum of elements in a given array
Program for factorial of a number
Operators in C / C++
Binary Search
Linear Search
Maximum and minimum of an array using minimum number of comparisons
Find the Missing Number
K'th Smallest/Largest Element in Unsorted Array | Set 1