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 = 2Output: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 = 7Output: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++

`// 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;` `}` |

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

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

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

## Javascript

`<script>` `// Javascript implementation of the approach` `// Function to return the highest` `// power of p that divides n` `function` `countFactors(n, p)` `{` ` ` `let 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]` `function` `getCount(l, r, p)` `{` ` ` `// To store the required count` ` ` `let cnt = 0;` ` ` `// For every element of the range` ` ` `for` `(let i = l; i <= r; i++) {` ` ` `// Add the highest power of` ` ` `// p that divides i` ` ` `cnt += countFactors(i, p);` ` ` `}` ` ` `return` `cnt;` `}` `// Driver code` ` ` `let l = 2, r = 8, p = 2;` ` ` `document.write(getCount(l, r, p));` `</script>` |

**Output:**

7

**Efficent approach:** Count the values which are divisible by **P, P ^{2}, P^{3}, …, P^{x}** in the range

**[L, R]**where

**x**is the largest power of

**P**such that

**P**lies within the upper bound (

^{x}**P**). Each iteration cost

^{x}â‰¤ N**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 <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;` `}` |

## Java

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

## Python3

`# Python3 implementation of the approach` `# 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 requried 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` `// 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;` ` ` `Console.WriteLine(getCount(l, r, p));` `}` `}` `// This code is contributed by PrinciRaj1992` |

## Javascript

`<script>` `// Javascript implementation of the approach` `// Function to return the count of times p` `// appaers in the prime factors of the` `// elements from the range [l, r]` `function` `getCount(l, r, p)` `{` ` ` `// To store the requried count` ` ` `let cnt = 0;` ` ` `let val = p;` ` ` `while` `(1) {` ` ` `// Number of values in the range [0, r]` ` ` `// that are divisible by val` ` ` `let a = parseInt(r / val);` ` ` `// Number of values in the range [0, l - 1]` ` ` `// that are divisible by val` ` ` `let b = parseInt((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` ` ` `let l = 2, r = 8, p = 2;` ` ` `document.write(getCount(l, r, p));` `</script>` |

**Output:**

7

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**