A factorial (of a large number) will usually contain some trailing zeros.
Your job is to make a function that calculates the number of trailing zeros, in any given base.
Factorial is defined like this:
```n! = 1 * 2 * 3 * 4 * ... * n-2 * n-1 * n```
Here's two examples to get you started:
```python
trailing_zeros(15, 10) == 3
#15! = 1307674368000, which has 3 zeros at the end
trailing_zeros(7, 2) == 4
#7! = 5030 = 0b1001110110000, which has 4 zeros at the end
```
Your code should be able to handle some very large numbers, so write some smart code.
Note: ```num``` will be a non-negative integer, ```base``` will be an integer larger or equal to two.
HINT: Should you not make any headway after trying a long time, you should try [this kata](https://www.codewars.com/kata/number-of-trailing-zeros-of-n) first.
from gmpy2 import is_prime,next_prime
def trailing_zeros(n,b):
    F,p=[],1
    while 1<b:
        p,c=next_prime(p),0
        while b%p==0:b,c=b//p,c+1
        F+=[(p,c)]*(0<c)
        if is_prime(b):F,b=F+[(b,1)],1
    Z=[]
    for e,c in F:
        m,t=n,0
        while 1<m:
            m,_=divmod(m,e)
            t+=m
        Z+=[t//c]
    return min(Z)
from gmpy2 import is_prime,next_prime
def trailing_zeros(n,b):
    F,p=[],1
    while 1<b:
        p,c=next_prime(p),0
        while b%p==0:b,c=b//p,c+1
        F+=[(p,c)]*(0<c)
        if is_prime(b):F,b=F+[(b,1)],1
    Z=[]
    for e,c in F:
        m,t=n,0
        while 1<m:
            m,_=divmod(m,e)
            t+=m
        Z+=[t//c]
    return min(Z)