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

• Last Updated : 18 Mar, 2022

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:

1 + 0 + 2 + 0 + 1 + 0 + 3 = 7
Input: L = 5, R = 25, P = 7
Output:

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++

 `// C++ implementation of the approach``#include ``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``// appears 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;``}`

## Java

 `// 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``// appears 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`

## Python3

 `# 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``# appears 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`

## C#

 `// 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``// appears 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`

## Javascript

 ``
Output:
`7`

Auxiliary Space: O(1)

Efficient 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++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to return the count of times p``// appears 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;``    ``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;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG``{` `// Function to return the count of times p``// appears 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``;``    ``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`

## Python3

 `# Python3 implementation of the approach` `# Function to return the count of times p``# appears in the prime factors of the``# elements from the range [l, r]``def` `getCount(l, r, p):` `    ``# To store the required count``    ``cnt ``=` `0``;``    ``val ``=` `p;``    ``while` `(``True``):` `        ``# Number of values in the range [0, r]``        ``# that are divisible by val``        ``a ``=` `r ``/``/` `val;` `        ``# Number of values in the range [0, l - 1]``        ``# that are divisible by val``        ``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` `int``(cnt);` `# Driver Code``l ``=` `2``;``r ``=` `8``;``p ``=` `2``;` `print``(getCount(l, r, p));` `# This code is contributed by princiraj`

## C#

 `// C# implementation of the approach``using` `System;``    ` `class` `GFG``{` `// Function to return the count of times p``// appears 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;``    ``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;` `    ``Console.WriteLine(getCount(l, r, p));``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``
Output:
`7`

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up