# Number of trailing zeroes in base B representation of N!

Given two positive integers B and N. The task is to find the number of trailing zeroes in b-ary (base B) representation of N! (factorial of N)

Examples:

```Input: N = 5, B = 2
Output: 3
5! = 120 which is represented as 1111000 in base 2.

Input: N = 6, B = 9
Output: 1
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A naive solution is to find the factorial of the given number and convert it into given base B. Then, count the number of trailing zeroes but that would be a costly operation. Also, it will not be easy to find the factorial of large numbers and store it in integer.

Efficient Approach: Suppose, the base is 10 i.e., decimal then we’ll have to calculate the highest power of 10 that divides N! using Legendre’s formula. Thus, number B is represented as 10 when converted into base B. Let’s say base B = 13, then 13 in base 13 will be represented as 10, i.e., 1310 = 1013. Hence, problem reduces to finding the highest power of B in N!. (Largest power of k in n!)

Below is the implementation of the above approach.

## C++

 `// CPP program to find the number of trailing ` `// zeroes in base B representation of N! ` `#include ` `using` `namespace` `std; ` ` `  `// To find the power of a prime p in ` `// factorial N ` `int` `findPowerOfP(``int` `N, ``int` `p) ` `{ ` `    ``int` `count = 0; ` `    ``int` `r = p; ` `    ``while` `(r <= N) { ` ` `  `        ``// calculating floor(n/r) ` `        ``// and adding to the count ` `        ``count += (N / r); ` ` `  `        ``// increasing the power of p ` `        ``// from 1 to 2 to 3 and so on ` `        ``r = r * p; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// returns all the prime factors of k ` `vector > primeFactorsofB(``int` `B) ` `{ ` `    ``// vector to store all the prime factors ` `    ``// along with their number of occurrence ` `    ``// in factorization of B ` `    ``vector > ans; ` ` `  `    ``for` `(``int` `i = 2; B != 1; i++) { ` `        ``if` `(B % i == 0) { ` `            ``int` `count = 0; ` `            ``while` `(B % i == 0) { ` `                ``B = B / i; ` `                ``count++; ` `            ``} ` ` `  `            ``ans.push_back(make_pair(i, count)); ` `        ``} ` `    ``} ` `    ``return` `ans; ` `} ` ` `  `// Returns largest power of B that ` `// divides N! ` `int` `largestPowerOfB(``int` `N, ``int` `B) ` `{ ` `    ``vector > vec; ` `    ``vec = primeFactorsofB(B); ` `    ``int` `ans = INT_MAX; ` `    ``for` `(``int` `i = 0; i < vec.size(); i++) ` ` `  `        ``// calculating minimum power of all ` `        ``// the prime factors of B ` `        ``ans = min(ans, findPowerOfP(N, ` `                                    ``vec[i].first) ` `                           ``/ vec[i].second); ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``cout << largestPowerOfB(5, 2) << endl; ` `    ``cout << largestPowerOfB(6, 9) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find the number of trailing ` `// zeroes in base B representation of N! ` `import` `java.util.*; ` `class` `GFG  ` `{ ` `static` `class` `pair ` `{  ` `    ``int` `first, second;  ` `    ``public` `pair(``int` `first, ``int` `second)  ` `    ``{  ` `        ``this``.first = first;  ` `        ``this``.second = second;  ` `    ``}  ` `}  ` ` `  `// To find the power of a prime p in ` `// factorial N ` `static` `int` `findPowerOfP(``int` `N, ``int` `p) ` `{ ` `    ``int` `count = ``0``; ` `    ``int` `r = p; ` `    ``while` `(r <= N) ` `    ``{ ` ` `  `        ``// calculating floor(n/r) ` `        ``// and adding to the count ` `        ``count += (N / r); ` ` `  `        ``// increasing the power of p ` `        ``// from 1 to 2 to 3 and so on ` `        ``r = r * p; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// returns all the prime factors of k ` `static` `Vector primeFactorsofB(``int` `B) ` `{ ` `    ``// vector to store all the prime factors ` `    ``// along with their number of occurrence ` `    ``// in factorization of B ` `    ``Vector ans = ``new` `Vector(); ` ` `  `    ``for` `(``int` `i = ``2``; B != ``1``; i++) ` `    ``{ ` `        ``if` `(B % i == ``0``)  ` `        ``{ ` `            ``int` `count = ``0``; ` `            ``while` `(B % i == ``0``) ` `            ``{ ` `                ``B = B / i; ` `                ``count++; ` `            ``} ` ` `  `            ``ans.add(``new` `pair(i, count)); ` `        ``} ` `    ``} ` `    ``return` `ans; ` `} ` ` `  `// Returns largest power of B that ` `// divides N! ` `static` `int` `largestPowerOfB(``int` `N, ``int` `B) ` `{ ` `    ``Vector vec = ``new` `Vector(); ` `    ``vec = primeFactorsofB(B); ` `    ``int` `ans = Integer.MAX_VALUE; ` `    ``for` `(``int` `i = ``0``; i < vec.size(); i++) ` ` `  `        ``// calculating minimum power of all ` `        ``// the prime factors of B ` `        ``ans = Math.min(ans, findPowerOfP( ` `                       ``N, vec.get(i).first) /  ` `                          ``vec.get(i).second); ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``System.out.println(largestPowerOfB(``5``, ``2``)); ` `    ``System.out.println(largestPowerOfB(``6``, ``9``)); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

## Python3

 `# Python 3 program to find the number of  ` `# trailing zeroes in base B representation of N! ` `import` `sys ` ` `  `# To find the power of a prime  ` `# p in factorial N ` `def` `findPowerOfP(N, p): ` `    ``count ``=` `0` `    ``r ``=` `p ` `    ``while` `(r <``=` `N): ` `         `  `        ``# calculating floor(n/r) ` `        ``# and adding to the count ` `        ``count ``+``=` `int``(N ``/` `r) ` ` `  `        ``# increasing the power of p ` `        ``# from 1 to 2 to 3 and so on ` `        ``r ``=` `r ``*` `p  ` `     `  `    ``return` `count ` ` `  `# returns all the prime factors of k ` `def` `primeFactorsofB(B): ` `     `  `    ``# vector to store all the prime factors ` `    ``# along with their number of occurrence ` `    ``# in factorization of B' ` `    ``ans ``=` `[] ` `    ``i ``=` `2` ` `  `    ``while``(B!``=` `1``): ` `        ``if` `(B ``%` `i ``=``=` `0``): ` `            ``count ``=` `0` `            ``while` `(B ``%` `i ``=``=` `0``): ` `                 `  `                ``B ``=` `int``(B ``/` `i) ` `                ``count ``+``=` `1` ` `  `            ``ans.append((i, count)) ` ` `  `        ``i ``+``=` `1` `     `  `    ``return` `ans ` ` `  `# Returns largest power of B that ` `# divides N! ` `def` `largestPowerOfB(N, B): ` `    ``vec ``=` `[] ` `    ``vec ``=` `primeFactorsofB(B) ` `    ``ans ``=` `sys.maxsize ` `     `  `    ``# calculating minimum power of all ` `    ``# the prime factors of B ` `    ``ans ``=` `min``(ans, ``int``(findPowerOfP(N, vec[``0``][``0``]) ``/`  `                                       ``vec[``0``][``1``])) ` ` `  `    ``return` `ans ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``print``(largestPowerOfB(``5``, ``2``)) ` `    ``print``(largestPowerOfB(``6``, ``9``)) ` `     `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# program to find the number of trailing ` `// zeroes in base B representation of N! ` `using` `System; ` `using` `System.Collections.Generic;  ` ` `  `class` `GFG  ` `{ ` `public` `class` `pair ` `{  ` `    ``public` `int` `first, second;  ` `    ``public` `pair(``int` `first, ``int` `second)  ` `    ``{  ` `        ``this``.first = first;  ` `        ``this``.second = second;  ` `    ``}  ` `}  ` ` `  `// To find the power of a prime p in ` `// factorial N ` `static` `int` `findPowerOfP(``int` `N, ``int` `p) ` `{ ` `    ``int` `count = 0; ` `    ``int` `r = p; ` `    ``while` `(r <= N) ` `    ``{ ` ` `  `        ``// calculating floor(n/r) ` `        ``// and adding to the count ` `        ``count += (N / r); ` ` `  `        ``// increasing the power of p ` `        ``// from 1 to 2 to 3 and so on ` `        ``r = r * p; ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// returns all the prime factors of k ` `static` `List primeFactorsofB(``int` `B) ` `{ ` `    ``// vector to store all the prime factors ` `    ``// along with their number of occurrence ` `    ``// in factorization of B ` `    ``List ans = ``new` `List(); ` ` `  `    ``for` `(``int` `i = 2; B != 1; i++) ` `    ``{ ` `        ``if` `(B % i == 0)  ` `        ``{ ` `            ``int` `count = 0; ` `            ``while` `(B % i == 0) ` `            ``{ ` `                ``B = B / i; ` `                ``count++; ` `            ``} ` ` `  `            ``ans.Add(``new` `pair(i, count)); ` `        ``} ` `    ``} ` `    ``return` `ans; ` `} ` ` `  `// Returns largest power of B that ` `// divides N! ` `static` `int` `largestPowerOfB(``int` `N, ``int` `B) ` `{ ` `    ``List vec = ``new` `List(); ` `    ``vec = primeFactorsofB(B); ` `    ``int` `ans = ``int``.MaxValue; ` `    ``for` `(``int` `i = 0; i < vec.Count; i++) ` ` `  `        ``// calculating minimum power of all ` `        ``// the prime factors of B ` `        ``ans = Math.Min(ans, findPowerOfP( ` `                       ``N, vec[i].first) /  ` `                          ``vec[i].second); ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``Console.WriteLine(largestPowerOfB(5, 2)); ` `    ``Console.WriteLine(largestPowerOfB(6, 9)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```3
1
```

My Personal Notes arrow_drop_up 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 Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.