Count occurrences of a prime number in the prime factorization of every element from the given range

Given three integers L, R and P where P is prime, the task is to count the number of times P occurs in the prime factorization of all numbers in the range [L, R].

Examples:

Input: L = 2, R = 8, P = 2
Output: 7

Element Prime Factors Time 2 occurs
2 2 1
3 3 0
4 2 * 2 2
5 5 0
6 2 * 3 1
7 7 0
8 2 * 2 * 2 3

1 + 0 + 2 + 0 + 1 + 0 + 3 = 7

Input: L = 5, R = 25, P = 7
Output: 3

Naive approach: Simply iterate over the range and for each value count how many times P divides that value and sum them up for the result. Time complexity O(R – L).

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
using namespace std;
  
// Function to return the highest
// power of p that divides n
int countFactors(int n, int p)
{
    int pwr = 0;
    while (n > 0 && n % p == 0) {
        n /= p;
        pwr++;
    }
    return pwr;
}
  
// Function to return the count of times p
// appaers in the prime factors of the
// elements from the range [l, r]
int getCount(int l, int r, int p)
{
  
    // To store the required count
    int cnt = 0;
  
    // For every element of the range
    for (int i = l; i <= r; i++) {
  
        // Add the highest power of
        // p that divides i
        cnt += countFactors(i, p);
    }
  
    return cnt;
}
  
// Driver code
int main()
{
    int l = 2, r = 8, p = 2;
  
    cout << getCount(l, r, p);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG 
{
  
// Function to return the highest
// power of p that divides n
static int countFactors(int n, int p)
{
    int pwr = 0;
    while (n > 0 && n % p == 0
    {
        n /= p;
        pwr++;
    }
    return pwr;
}
  
// Function to return the count of times p
// appaers in the prime factors of the
// elements from the range [l, r]
static int getCount(int l, int r, int p)
{
  
    // To store the required count
    int cnt = 0;
  
    // For every element of the range
    for (int i = l; i <= r; i++) 
    {
  
        // Add the highest power of
        // p that divides i
        cnt += countFactors(i, p);
    }
    return cnt;
}
  
// Driver code
public static void main(String[] args)
{
    int l = 2, r = 8, p = 2;
  
    System.out.println(getCount(l, r, p));
}
  
// This code is contributed by Rajput-Ji

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach 
  
# Function to return the highest 
# power of p that divides n 
def countFactors(n, p) : 
  
    pwr = 0
      
    while (n > 0 and n % p == 0) :
        n //= p; 
        pwr += 1
          
    return pwr; 
  
# Function to return the count of times p 
# appaers in the prime factors of the 
# elements from the range [l, r] 
def getCount(l, r, p) : 
  
    # To store the required count 
    cnt = 0
  
    # For every element of the range 
    for i in range(l, r + 1) :
  
        # Add the highest power of 
        # p that divides i 
        cnt += countFactors(i, p); 
  
    return cnt; 
  
# Driver code 
if __name__ == "__main__"
  
    l = 2; r = 8; p = 2
  
    print(getCount(l, r, p)); 
  
# This code is contributed by AnkitRai01

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
  
class GFG 
{
  
// Function to return the highest
// power of p that divides n
static int countFactors(int n, int p)
{
    int pwr = 0;
    while (n > 0 && n % p == 0) 
    {
        n /= p;
        pwr++;
    }
    return pwr;
}
  
// Function to return the count of times p
// appaers in the prime factors of the
// elements from the range [l, r]
static int getCount(int l, int r, int p)
{
  
    // To store the required count
    int cnt = 0;
  
    // For every element of the range
    for (int i = l; i <= r; i++) 
    {
  
        // Add the highest power of
        // p that divides i
        cnt += countFactors(i, p);
    }
    return cnt;
}
  
// Driver code
public static void Main(String[] args)
{
    int l = 2, r = 8, p = 2;
  
    Console.WriteLine(getCount(l, r, p));
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

7

Efficent approach: Count the values which are divisible by P, P2, P3, …, Px in the range [L, R] where x is the largest power of P such that Px lies within the upper bound (Px ≤ N). Each iteration cost O(1) time thus time complexity becomes O(x) where x = (log(R) / log(P)).

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
using namespace std;
  
// Function to return the count of times p
// appaers in the prime factors of the
// elements from the range [l, r]
int getCount(int l, int r, int p)
{
  
    // To store the requried count
    int cnt = 0;
    int val = p;
    while (1) {
  
        // Number of values in the range [0, r]
        // that are divisible by val
        int a = r / val;
  
        // Number of values in the range [0, l - 1]
        // that are divisible by val
        int b = (l - 1) / val;
  
        // Increment the power of the val
        val *= p;
  
        // (a - b) is the count of numbers in the
        // range [l, r] that are divisible by val
        if (a - b) {
            cnt += (a - b);
        }
  
        // No values that are divisible by val
        // thus exiting from the loop
        else
            break;
    }
  
    return cnt;
}
  
// Driver code
int main()
{
    int l = 2, r = 8, p = 2;
  
    cout << getCount(l, r, p);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.*;
  
class GFG 
{
  
// Function to return the count of times p
// appaers in the prime factors of the
// elements from the range [l, r]
static int getCount(int l, int r, int p)
{
  
    // To store the requried count
    int cnt = 0;
    int val = p;
    while (true
    {
  
        // Number of values in the range [0, r]
        // that are divisible by val
        int a = r / val;
  
        // Number of values in the range [0, l - 1]
        // that are divisible by val
        int b = (l - 1) / val;
  
        // Increment the power of the val
        val *= p;
  
        // (a - b) is the count of numbers in the
        // range [l, r] that are divisible by val
        if ((a - b) > 0
        {
            cnt += (a - b);
        }
  
        // No values that are divisible by val
        // thus exiting from the loop
        else
            break;
    }
    return cnt;
}
  
// Driver code
public static void main(String[] args)
{
    int l = 2, r = 8, p = 2;
  
    System.out.println(getCount(l, r, p));
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

7


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

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.