Given an integer Y, find the smallest number X such that X! contains at least Y trailing zeros.
Prerequisites – Count trailing zeroes in factorial of a number
Examples:
Input : Y = 2
Output : 10
10! = 3628800, which has 2 trailing zeros. 9! = 362880, which has 1 trailing zero. Hence, 10 is the correct answer.Input : Y = 6
Output : 25
25! = 15511210043330985984000000, which has 6 trailing zeros. 24! = 620448401733239439360000, which has 4 trailing zeros. Hence, 25 is the correct answer.
Approach: The problem can be easily solved by using Binary Search. The number of trailing zeros in N! is given by the count of the factors 5 in N!.Read this article for prerequisites. The countFactor(5, N) function returns the count of factor 5 in N! which is equal to count of trailing zeros in N!. The smallest number X such that X! contains at least Y trailing zeros can be computed quickly by using binary search on a range [0, 5 * Y] using this function.
Below is the implementation of above approach.
// 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
Time Complexity: O(log2Y * log5Y)
Space Complexity: O(log5Y)
The extra space is used due to recursion call stack of countFactor() function.