Sum of largest divisible powers of p (a prime number) in a range

3.3

Given a range [L, R], and a prime number P. We are required to find the sum of the highest power of P in all numbers from L to R.

Examples:

Input : L = 1, R = 10, P = 2
Output : 8
There are 10 integers in the range, and:
In 1 the highest power of 2 is 0
In 2 the highest power of 2 is 1
In 3 the highest power of 2 is 0
Similarly the highest powers of 2 in 4, 
5, 6, 7, 8, 9, 10 are 2, 0, 1, 0, 3, 
0, 1 respectively.

Input : L = 10, R = 20, P = 7
Output : 1
There are 11 integers in the range, and:
In 10 the highest power of 7 is 0
In 11 the highest power of 7 is 0
In 12 the highest power of 7 is 0
Similarly the highest power of 7 in 13,
14, 15, 16, 17, 18, 19, 20 and 10 is 0,
1, 0, 0, 0, 0, 0 and 0 respectively.

Native Approach : Run a loop from L to R. For every number, check if it is divisible by P. If yes, then find the largest power of P that divides current number. If yes, then add this value to result.

C++

// Simple CPP Program to find sum of largest
// divisible powers of P in [L, R]
#include <bits/stdc++.h>
using namespace std;

int sumOfDivisblePowers(int L, int R, int P) {

   // Traverse through all numbers from L to R
   int res = 0;
   for (int i = L; i <= R; i++)
   {
      // If P divides current number x, add 
      // largest power of P that divides x.
      int x = i;
      while (x % P == 0)
      {
         res++;
         x  /= P;
      }
   }

   return res;
}

// Driver code
int main() {
  int L = 1, R = 10, P = 2;
  cout << sumOfDivisblePowers(L, R, P);
  return 0;
}

Java

// Simple Java Program to find sum of largest
// divisible powers of P in [L, R]

class GFG 
{
    // Utility Function
    static int sumOfDivisblePowers(int L, int R, int P) 
    {
        // Traverse through all numbers from L to R
        int res = 0;
        for (int i = L; i <= R; i++)
        {
            // If P divides current number x, add 
            // largest power of P that divides x.
            int x = i;
            while (x % P == 0)
            {
                res++;
                x /= P;
            }
        }
        
        return res;
    }

    // Driver code
    public static void main (String[] args) 
    {
        int L = 1, R = 10, P = 2;
        System.out.println(sumOfDivisblePowers(L, R, P));
    }
}

// This code is contributed by Anant Agarwal.

Output:

8

 

Efficient approach: The idea is to use to Legendre’s formula.

The largest possible power of P that divides factorial of a number x is ⌊x/p⌋ + ⌊x/(p2)⌋ + ⌊x/(p3)⌋ + ……

Using above, we can find the largest power of P that divides R! (or 1 * 2 * 3…. R).

Sum of largest powers from L to R = Largest Power of P that divides R! (or 1 * 2 … L-1 * L * … R) – Largest Power of P that divides (L-1)! (or 1 * 2 … L-1)

C++

// Efficient CPP Program to find sum of 
// largest divisible powers of P in [L, R]
#include <bits/stdc++.h>
using namespace std;

// Implements Lagrange's theorem (Finds largest
// power of P that divides x!
int largestPower(int x, int P)
{ 
    // Calculate x/p + x/(p^2) + x/(p^3) + ....
    int res = 0;
    while (x)
    {
        x /= P;
        res += x;
    }
    return res;
}

// Returns sum of largest powers of P that divide
// numbers in range from L to R.
int sumOfDivisblePowers(int L, int R, int P) {
    return largestPower(R, P) - largestPower(L-1, P);
}

// Driver code
int main() {
  int L = 1, R = 10, P = 2;
  cout << sumOfDivisblePowers(L, R, P);
  return 0;
}

Java

// Efficient CPP Program to find sum of 
// largest divisible powers of P in [L, R]

class GFG 
{
    // Implements Lagrange's theorem 
    // (Finds largest power of P that
    // divides x!
    static int largestPower(int x, int P)
    { 
        // Calculate x/p + x/(p^2) + x/(p^3) + ....
        int res = 0;
        while(x != 0)
        {
            x /= P;
            res += x;
        }
        return res;
    }

    // Returns sum of largest powers 
    // of P that divide numbers in 
    // range from L to R.
    static int sumOfDivisblePowers(int L, int R, int P) 
    {
        return largestPower(R, P) - largestPower(L-1, P);
    }

    // Driver code
    public static void main (String[] args)
    {
        int L = 1, R = 10, P = 2;
        System.out.println(sumOfDivisblePowers(L, R, P));
    }
}

// This code is contributed by Anant Agarwal.

Output:

8

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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

GATE CS Corner    Company Wise Coding Practice

Recommended Posts:



3.3 Average Difficulty : 3.3/5.0
Based on 3 vote(s)