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

Last Updated : 05 Mar, 2023

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`

Time complexity : O((r-l+1)*log p) because the for loop runs (r-l+1) times and each iteration of the loop takes log p time due to the countFactors() function.

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`

Time complexity: O(log(r) * log(r))

Auxiliary Space: O(1)

Previous
Next