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

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.

Python3

# Simple Python 3 Program to find sum of largest
# divisible powers of P in [L, R]

def sumOfDivisblePowers(L, R, P): 

    # Traverse through all numbers from L to R
    res = 0
    for i in range(L, R + 1):
    
        # If P divides current number x, add 
        # largest power of P that divides x.
        x = i
        while (x % P == 0):
        
            res += 1
            x /= P
    
    return res


# Driver code
L = 1
R = 10
P = 2
print(sumOfDivisblePowers(L, R, P))

# This code is contributed by Smitha Dinesh Semwal

C#


// Simple C# Program to find sum of
// largest divisible powers of P in 
// [L, R]
using System;

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 () 
    {
        int L = 1, R = 10, P = 2;
        Console.WriteLine(sumOfDivisblePowers(L, R, P));
    }
}

// This code is contributed by vt_m.

PHP


<?php
// Simple PHP Program to
// find sum of largest
// divisible powers of 
// P in [L, R]

// function return result
function sumOfDivisblePowers($L, $R, $P) 
{

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

return $res;
}

    // Driver Code
    $L = 1; 
    $R = 10; 
    $P = 2;
    echo sumOfDivisblePowers($L, $R, $P);

// This code is contributed by ajit
?>

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.

Python3

# Efficient Python 3 Program to find sum of 
# largest divisible powers of P in [L, R]

# Implements Lagrange's theorem (Finds largest
# power of P that divides x!
def largestPower(x, P):

    # Calculate x/p + x/(p^2) + x/(p^3) + ....
    res = 0
    while (x):
    
        x = int(x / P)
        res += x
    
    return res


# Returns sum of largest powers of P that divide
# numbers in range from L to R.
def sumOfDivisblePowers( L, R, P) :
    return largestPower(R, P) - largestPower(L-1, P)


# Driver code
L = 1
R = 10
P = 2
print(sumOfDivisblePowers(L, R, P))

# This code is contributed by Smitha Dinesh Semwal

C#

// Efficient C# Program to find sum of 
// largest divisible powers of P in [L, R]
using System;

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 Program to test above
    // function
    static void Main() 
    {
        int L = 1, R = 10, P = 2;
        Console.Write(
            sumOfDivisblePowers(L, R, P));
    }
}

// This code is contributed by Anuj_67

PHP


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

// Implements Lagrange's theorem (Finds largest
// power of P that divides x!
function largestPower($x, $P)
{ 

    // Calculate x/p + x/(p^2) + x/(p^3) + ....
    $res = 0;
    while ($x)
    {
        $x = floor($x/$P);
        $res += $x;
    }
    return $res;
}

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

// Driver code
$L = 1;
$R = 10;
$P = 2;
echo sumOfDivisblePowers($L, $R, $P);

//This code is contributed by mits.
?>
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.

Recommended Posts:



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