 GeeksforGeeks App
Open App Browser
Continue

## Related Articles

• Write an Interview Experience
• Mathematical Algorithms

# Largest power of k in n! (factorial) where k may not be prime

Given two numbers k and n, find the largest power of k that divides n!
Constraints:  K > 1

Examples:

```Input : n = 7, k = 2
Output : 4
Explanation : 7! = 5040
The largest power of 2 that
divides 5040 is 24.

Input : n = 10, k = 9
Output :  2
The largest power of 9 that
divides 10! is 92.```

We have discussed a solution in below post when k is always prime.
Legendre’s formula (Given p and n, find the largest x such that p^x divides n!)
Now to find the power of any non-prime number k in n!, we first find all the prime factors of the number k along with the count of number of their occurrences. Then for each prime factor, we count occurrences using Legendre’s formula which states that the largest possible power of a prime number p in n is ⌊n/p⌋ + ⌊n/(p2)⌋ + ⌊n/(p3)⌋ + ……
Over all the prime factors p of K, the one with the minimum value of findPowerOfK(n, p)/count will be our answer where count is number of occurrences of p in k.

## C++

 `// CPP program to find the largest power``// of k that divides 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 > primeFactorsofK(``int` `k)``{``    ``// vector to store all the prime factors``    ``// along with their number of occurrence``    ``// in factorization of k``    ``vector > ans;` `    ``for` `(``int` `i = 2; k != 1; i++) {``        ``if` `(k % i == 0) {``            ``int` `count = 0;``            ``while` `(k % i == 0) {``                ``k = k / i;``                ``count++;``            ``}` `            ``ans.push_back(make_pair(i, count));``        ``}``    ``}``    ``return` `ans;``}` `// Returns largest power of k that``// divides n!``int` `largestPowerOfK(``int` `n, ``int` `k)``{``    ``vector > vec;``    ``vec = primeFactorsofK(k);``    ``int` `ans = INT_MAX;``    ``for` `(``int` `i = 0; i < vec.size(); i++)` `        ``// calculating minimum power of all``        ``// the prime factors of k``        ``ans = min(ans, findPowerOfP(n,``              ``vec[i].first) / vec[i].second);` `    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``cout << largestPowerOfK(7, 2) << endl;``    ``cout << largestPowerOfK(10, 9) << endl;``    ``return` `0;``}`

## Java

 `// JAVA program to find the largest power``// of k that divides 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 Math.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 primeFactorsofK(``int` `k)``{``    ``// vector to store all the prime factors``    ``// along with their number of occurrence``    ``// in factorization of k``    ``Vector ans = ``new` `Vector();` `    ``for` `(``int` `i = ``2``; k != ``1``; i++)``    ``{``        ``if` `(k % i == ``0``)``        ``{``            ``int` `count = ``0``;``            ``while` `(k % i == ``0``)``            ``{``                ``k = k / i;``                ``count++;``            ``}` `            ``ans.add(``new` `pair(i, count));``        ``}``    ``}``    ``return` `ans;``}` `// Returns largest power of k that``// divides n!``static` `int` `largestPowerOfK(``int` `n, ``int` `k)``{``    ``Vector vec = ``new` `Vector();``    ``vec = primeFactorsofK(k);``    ``int` `ans = Integer.MAX_VALUE;``    ``for` `(``int` `i = ``0``; i < vec.size(); i++)` `        ``// calculating minimum power of all``        ``// the prime factors of k``        ``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.print(largestPowerOfK(``7``, ``2``) +``"\n"``);``    ``System.out.print(largestPowerOfK(``10``, ``9``) +``"\n"``);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to find the largest power``# of k that divides 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 ``+``=` `(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` `primeFactorsofK(k) :` `    ``# vector to store all the prime factors``    ``# along with their number of occurrence``    ``# in factorization of k``    ``ans ``=` `[]``    ``i ``=` `2``    ``while` `k !``=` `1` `:``        ``if` `k ``%` `i ``=``=` `0` `:``            ``count ``=` `0``            ``while` `k ``%` `i ``=``=` `0` `:``                ``k ``=` `k ``/``/` `i``                ``count ``+``=` `1``            ``ans.append([i , count])``        ``i ``+``=` `1` `    ``return` `ans` `# Returns largest power of k that``# divides n!``def` `largestPowerOfK(n, k) :` `    ``vec ``=` `primeFactorsofK(k)``    ``ans ``=` `sys.maxsize``    ``for` `i ``in` `range``(``len``(vec)) :` `        ``# calculating minimum power of all``        ``# the prime factors of k``        ``ans ``=` `min``(ans, findPowerOfP(n, vec[i][``0``]) ``/``/` `vec[i][``1``])` `    ``return` `ans` `print``(largestPowerOfK(``7``, ``2``))``print``(largestPowerOfK(``10``, ``9``))` `# This code is contributed by divyesh072019`

## C#

 `// C# program to find the largest power``// of k that divides n!``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{``    ` `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 Math.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 primeFactorsofK(``int` `k)``{``    ``// vector to store all the prime factors``    ``// along with their number of occurrence``    ``// in factorization of k``    ``List ans = ``new` `List();` `    ``for` `(``int` `i = 2; k != 1; i++)``    ``{``        ``if` `(k % i == 0)``        ``{``            ``int` `count = 0;``            ``while` `(k % i == 0)``            ``{``                ``k = k / i;``                ``count++;``            ``}` `            ``ans.Add(``new` `pair(i, count));``        ``}``    ``}``    ``return` `ans;``}` `// Returns largest power of k that``// divides n!``static` `int` `largestPowerOfK(``int` `n, ``int` `k)``{``    ``List vec = ``new` `List();``    ``vec = primeFactorsofK(k);``    ``int` `ans = ``int``.MaxValue;``    ``for` `(``int` `i = 0; i < vec.Count; i++)` `        ``// calculating minimum power of all``        ``// the prime factors of k``        ``ans = Math.Min(ans, findPowerOfP(n,``            ``vec[i].first) / vec[i].second);` `    ``return` `ans;``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``Console.Write(largestPowerOfK(7, 2) +``"\n"``);``    ``Console.Write(largestPowerOfK(10, 9) +``"\n"``);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

```4
2```

Time Complexity: O(k*log(n))
Auxiliary Space: O(k)
This article is contributed by ShivamKD. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Approach 2: –Another approach to find the largest power of a non-prime number k in n! is by using the concept of the number of times a factor appears in a number’s prime factorization. The number of times a factor p appears in n! is given by the sum of the quotients n/p, n/p^2, n/p^3, and so on until the quotient becomes 0.

We can extend this concept to find the largest power of k in n! by considering the prime factorization of k. If k can be written as a product of primes, say k = p1^a1 * p2^a2 * … * pk^ak, then the largest power of k in n! is given by the minimum of the largest powers of each prime pi in k.

## C++

 `#include ``using` `namespace` `std;` `int` `largestPower(``int` `n, ``int` `k) {``    ``// find prime factorization of k and their respective exponents``    ``map<``int``, ``int``> factors;``    ``for``(``int` `i=2; i*i<=k; i++) {``        ``while``(k % i == 0) {``            ``factors[i]++;``            ``k /= i;``        ``}``    ``}``    ``if``(k > 1) factors[k]++;``    ` `    ``int` `minPower = INT_MAX;``    ``// find the largest power of each prime factor and take their minimum``    ``for``(``auto` `it : factors) {``        ``int` `p = it.first, a = it.second;``        ``int` `power = 0;``        ``for``(``long` `long` `i=p; i<=n; i*=p) {``            ``power += n/i;``        ``}``        ``minPower = min(minPower, power/a);``    ``}``    ``return` `minPower;``}` `int` `main() {``    ``cout<

## Java

 `// Java code of above approach``import` `java.util.*;` `class` `Solution {` `public` `static` `int` `largestPower(``int` `n, ``int` `k) {``// find prime factorization of k and their respective exponents``Map factors = ``new` `HashMap<>();``for` `(``int` `i = ``2``; i * i <= k; i++) {``while` `(k % i == ``0``) {``factors.put(i, factors.getOrDefault(i, ``0``) + ``1``);``k /= i;``}``}``if` `(k > ``1``) factors.put(k, factors.getOrDefault(k, ``0``) + ``1``);` `    ``int` `minPower = Integer.MAX_VALUE;``    ``// find the largest power of each prime factor and take their minimum``    ``for` `(Map.Entry entry : factors.entrySet()) {``        ``int` `p = entry.getKey();``        ``int` `a = entry.getValue();``        ``int` `power = ``0``;``        ``for` `(``long` `i = p; i <= n; i *= p) {``            ``power += n / i;``        ``}``        ``minPower = Math.min(minPower, power / a);``    ``}``    ``return` `minPower;``}` `  ``// Driver code``public` `static` `void` `main(String[] args) {``  ` `  ``//  calling largest power function``    ``System.out.println(largestPower(``7``, ``2``));``    ``System.out.println(largestPower(``10``, ``9``));``}``}`

## Python3

 `import` `math` `def` `largestPower(n, k):``    ``# find prime factorization of k and their respective exponents``    ``factors ``=` `{}``    ``i ``=` `2``    ``while` `i``*``i <``=` `k:``        ``while` `k ``%` `i ``=``=` `0``:``            ``if` `i ``in` `factors:``                ``factors[i] ``+``=` `1``            ``else``:``                ``factors[i] ``=` `1``            ``k ``/``/``=` `i``        ``i ``+``=` `1``    ``if` `k > ``1``:``        ``if` `k ``in` `factors:``            ``factors[k] ``+``=` `1``        ``else``:``            ``factors[k] ``=` `1``    ` `    ``minPower ``=` `math.inf``    ``# find the largest power of each prime factor and take their minimum``    ``for` `p, a ``in` `factors.items():``        ``power ``=` `0``        ``i ``=` `p``        ``while` `i <``=` `n:``            ``power ``+``=` `n``/``/``i``            ``i ``*``=` `p``        ``minPower ``=` `min``(minPower, power``/``/``a)``    ` `    ``return` `minPower` `print``(largestPower(``7``,``2``))``print``(largestPower(``10``,``9``))`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `MainClass {``    ``static` `int` `LargestPower(``int` `n, ``int` `k)``    ``{``        ``// find prime factorization of k and their``        ``// respective exponents``        ``Dictionary<``int``, ``int``> factors``            ``= ``new` `Dictionary<``int``, ``int``>();``        ``for` `(``int` `i = 2; i * i <= k; i++) {``            ``while` `(k % i == 0) {``                ``if` `(!factors.ContainsKey(i))``                    ``factors[i] = 0;``                ``factors[i]++;``                ``k /= i;``            ``}``        ``}``        ``if` `(k > 1 && !factors.ContainsKey(k))``            ``factors[k] = 1;``        ``else` `if` `(k > 1)``            ``factors[k]++;``        ``int` `minPower = ``int``.MaxValue;``        ``// find the largest power of each prime factor and``        ``// take their minimum``        ``foreach``(KeyValuePair<``int``, ``int``> kvp ``in` `factors)``        ``{``            ``int` `p = kvp.Key, a = kvp.Value;``            ``int` `power = 0;``            ``for` `(``long` `i = p; i <= n; i *= p) {``                ``power += (``int``)(n / i);``            ``}``            ``minPower = Math.Min(minPower, power / a);``        ``}``        ``return` `minPower;``    ``}` `    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``Console.WriteLine(LargestPower(7, 2));``        ``Console.WriteLine(LargestPower(10, 9));``    ``}``}`

## Javascript

 `function` `largestPower(n, k) {``    ``// find prime factorization of k and their respective exponents``    ``let factors = {};``    ``let i = 2;``    ``while` `(i*i <= k) {``        ``while` `(k % i === 0) {``            ``if` `(factors[i]) {``                ``factors[i] += 1;``            ``} ``else` `{``                ``factors[i] = 1;``            ``}``            ``k /= i;``        ``}``        ``i += 1;``    ``}``    ``if` `(k > 1) {``        ``if` `(factors[k]) {``            ``factors[k] += 1;``        ``} ``else` `{``            ``factors[k] = 1;``        ``}``    ``}` `    ``let minPower = Infinity;``    ``// find the largest power of each prime factor and take their minimum``    ``for` `(let p ``in` `factors) {``        ``if` `(factors.hasOwnProperty(p)) {``            ``let a = factors[p];``            ``let power = 0;``            ``i = p;``            ``while` `(i <= n) {``                ``power += Math.floor(n/i);``                ``i *= p;``            ``}``            ``minPower = Math.min(minPower, Math.floor(power/a));``        ``}``    ``}` `    ``return` `minPower;``}` `console.log(largestPower(7,2));``console.log(largestPower(10,9));`

Output

```4
2```

Time complexity:- O(sqrt(k) + log n).

Auxiliary Space: O(logN)

My Personal Notes arrow_drop_up