¡Encuentra el número X más pequeño tal que X! contiene al menos Y ceros finales.

Dado un entero Y, encuentre el número X más pequeño tal que X! contiene al menos Y ceros finales. 
Requisitos previos: cuente los ceros finales en el factorial de un número

Ejemplos: 

Entrada: Y = 2 
Salida: 10 
10! = 3628800, que tiene 2 ceros finales. 9! = 362880, que tiene 1 cero final. Por lo tanto, 10 es la respuesta correcta.

Entrada: Y = 6 
Salida: 25 
25! = 15511210043330985984000000, que tiene 6 ceros al final. 24! = 620448401733239439360000, que tiene 4 ceros al final. Por lo tanto, 25 es la respuesta correcta. 
 

Enfoque: el problema se puede resolver fácilmente utilizando la búsqueda binaria . El número de ceros finales en N! está dado por el conteo de los factores 5 en N!. Lea este artículo para conocer los requisitos previos. ¡La función countFactor(5, N) devuelve el recuento del factor 5 en N! que es igual al recuento de ceros finales en N!. El número X más pequeño tal que X! contiene al menos Y ceros finales se puede calcular rápidamente usando la búsqueda binaria en un rango [0, 5 * Y] usando esta función.

A continuación se muestra la implementación del enfoque anterior.  

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the number
// of factors P in X!
int countFactor(int P, int X)
{
    if (X < P)
        return 0;
 
    return (X / P + countFactor(P, X / P));
}
 
// Function to find the smallest X such
// that X! contains Y trailing zeros
int findSmallestX(int Y)
{
    int low = 0, high = 5 * Y;
    int N = 0;
    while (low <= high) {
        int mid = (high + low) / 2;
 
        if (countFactor(5, mid) < Y) {
            low = mid + 1;
        }
 
        else {
            N = mid;
            high = mid - 1;
        }
    }
 
    return N;
}
 
// Driver code
int main()
{
    int Y = 10;
 
    cout << findSmallestX(Y);
 
    return 0;
}

// Java implementation of the above approach
class GFG
{
     
    // Function to count the number
    // of factors P in X!
    static int countFactor(int P, int X)
    {
        if (X < P)
            return 0;
     
        return (X / P + countFactor(P, X / P));
    }
     
    // Function to find the smallest X such
    // that X! contains Y trailing zeros
    static int findSmallestX(int Y)
    {
        int low = 0, high = 5 * Y;
        int N = 0;
        while (low <= high)
        {
            int mid = (high + low) / 2;
     
            if (countFactor(5, mid) < Y)
            {
                low = mid + 1;
            }
     
            else
            {
                N = mid;
                high = mid - 1;
            }
        }
     
        return N;
    }
     
    // Driver code
    public static void main(String args[])
    {
        int Y = 10;
     
        System.out.println(findSmallestX(Y));
    }
}
 
// This code is contributed by Ryuga

# Python3 implementation of the approach
 
# Function to count the number
# of factors P in X!
def countFactor(P, X):
    if (X < P):
        return 0;
 
    return (X // P + countFactor(P, X // P));
 
# Function to find the smallest X such
# that X! contains Y trailing zeros
def findSmallestX(Y):
 
    low = 0;
    high = 5 * Y;
    N = 0;
    while (low <= high):
        mid = (high + low) // 2;
 
        if (countFactor(5, mid) < Y):
            low = mid + 1;
 
        else:
            N = mid;
            high = mid - 1;
 
    return N;
 
# Driver code
Y = 10;
 
print(findSmallestX(Y));
 
# This code is contributed by mits

// C# implementation of the approach
class GFG
{
     
// Function to count the number
// of factors P in X!
static int countFactor(int P, int X)
{
    if (X < P)
        return 0;
 
    return (X / P + countFactor(P, X / P));
}
 
// Function to find the smallest X such
// that X! contains Y trailing zeros
static int findSmallestX(int Y)
{
    int low = 0, high = 5 * Y;
    int N = 0;
    while (low <= high)
    {
        int mid = (high + low) / 2;
 
        if (countFactor(5, mid) < Y)
        {
            low = mid + 1;
        }
 
        else
        {
            N = mid;
            high = mid - 1;
        }
    }
 
    return N;
}
 
// Driver code
static void Main()
{
    int Y = 10;
 
    System.Console.WriteLine(findSmallestX(Y));
}
}
 
// This code is contributed by mits

<?php
// PHP implementation of the above approach
 
// Function to count the number
// of factors P in X!
function countFactor($P, $X)
{
    if ($X < $P)
        return 0;
 
    return ((int)($X / $P) +
             countFactor($P, ($X / $P)));
}
 
// Function to find the smallest X such
// that X! contains Y trailing zeros
function findSmallestX($Y)
{
    $low = 0; $high = 5 * $Y;
    $N = 0;
    while ($low <= $high)
    {
        $mid = (int)(($high + $low) / 2);
 
        if (countFactor(5, $mid) < $Y)
        {
            $low = $mid + 1;
        }
 
        else
        {
            $N = $mid;
            $high = $mid - 1;
        }
    }
 
    return $N;
}
 
// Driver code
$Y = 10;
 
echo(findSmallestX($Y));
 
// This code is contributed by Code_Mech.
?>

<script>
 
// Javascript implementation of the approach
 
// Function to count the number
// of factors P in X!
function countFactor(P, X)
{
    if (X < P)
        return 0;
 
    return (parseInt(X / P) +
    countFactor(P, parseInt(X / P)));
}
 
// Function to find the smallest X such
// that X! contains Y trailing zeros
function findSmallestX(Y)
{
    let low = 0, high = 5 * Y;
    let N = 0;
     
    while (low <= high)
    {
        let mid = parseInt((high + low) / 2);
 
        if (countFactor(5, mid) < Y)
        {
            low = mid + 1;
        }
        else
        {
            N = mid;
            high = mid - 1;
        }
    }
    return N;
}
 
// Driver code
let Y = 10;
 
document.write(findSmallestX(Y));
 
// This code is contributed by subhammahato348
 
</script>

45