计算给定范围内每个元素的素数分解中素数的出现

给定三个整数L ， R和P ，其中P为质数，任务是计算范围[L，R]中所有数的质数分解中P发生的次数。

例子：

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

天真的方法：简单地遍历该范围，并为每个值计数P将该值除以多少次并将其求和得出结果。时间复杂度O(R – L) 。

下面是上述方法的实现：

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

输出：

7

有效方法：计算在[L，R]范围内被P，P ² ，P ³ ，…，P ^x整除的值，其中x是P的最大幂，以使P ^x处在上限( P ^x ≤N )。每次迭代花费O(1)时间，因此时间复杂度变为O(x) ，其中x =(log(R)/ log(P)) 。

下面是上述方法的实现：

C++

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

输出：

7