Number of trailing zeroes in base 16 representation of N!

Given an integer N, the task is to find the number of trailing zeroes in the base 16 representation of the factorial of N.

Examples:

Input: N = 6 
Output: 1 
6! = 720 (base 10) = 2D0 (base 16)

Input: N = 100 
Output: 24 

Approach:

• Number of trailing zeroes would be the highest power of 16 in the factorial of N in base 10.
• We know that 16 = 2⁴. So, the highest power of 16 is equal to the highest power 2 in the factorial of N divided by 4.
• To calculate the highest power of 2 in N!, we can use Legendre’s Formula.

Below is the implementation of the above approach: 

C++

// C++ implementation of the approach
#include <bits/stdc++.h>
#define ll long long int
using namespace std;

// Function to return the count of trailing zeroes
ll getTrailingZeroes(ll n)
{
    ll count = 0;
    ll val, powerTwo = 2;

    // Implementation of the Legendre's formula
    do {
        val = n / powerTwo;
        count += val;
        powerTwo *= 2;
    } while (val != 0);

    // Count has the highest power of 2
    // that divides n! in base 10
    return (count / 4);
}

// Driver code
int main()
{
    int n = 6;
    cout << getTrailingZeroes(n);
}

Java

// Java implementation of the approach
class GfG
{

// Function to return the count of trailing zeroes
static long getTrailingZeroes(long n)
{
    long count = 0;
    long val, powerTwo = 2;

    // Implementation of the Legendre's formula
    do
    {
        val = n / powerTwo;
        count += val;
        powerTwo *= 2;
    } while (val != 0);

    // Count has the highest power of 2
    // that divides n! in base 10
    return (count / 4);
}

// Driver code
public static void main(String[] args)
{
    int n = 6;
    System.out.println(getTrailingZeroes(n));
}
}

// This code is contributed by
// Prerna Saini.

Python3

# Python3 implementation of the approach

# Function to return the count of
# trailing zeroes
def getTrailingZeroes(n):

    count = 0
    val, powerTwo = 1, 2

    # Implementation of the Legendre's
    # formula
    while (val != 0):
        val = n //powerTwo
        count += val
        powerTwo *= 2

    # Count has the highest power of 2
    # that divides n! in base 10
    return (count // 4)

# Driver code
n = 6
print(getTrailingZeroes(n))

# This code is contributed
# by Mohit Kumar

C#

// C# implementation of the approach
using System;
class GFG
{

// Function to return the count of
// trailing zeroes
static long getTrailingZeroes(long n)
{
    long count = 0;
    long val, powerTwo = 2;

    // Implementation of the
    // Legendre's formula
    do
    {
        val = n / powerTwo;
        count += val;
        powerTwo *= 2;
    } while (val != 0);

    // Count has the highest power of 2
    // that divides n! in base 10
    return (count / 4);
}

// Driver code
public static void Main()
{
    int n = 6;
    Console.Write(getTrailingZeroes(n));
}
}

// This code is contributed by
// Akanksha Rai

PHP

<?php
// PHP implementation of the approach

// Function to return the count of
// trailing zeroes
function getTrailingZeroes($n)
{
    $count = 0;
    $val; $powerTwo = 2;

    // Implementation of the Legendre's formula
    do
    {
        $val = (int)($n / $powerTwo);
        $count += $val;
        $powerTwo *= 2;
    } while ($val != 0);

    // Count has the highest power of 2
    // that divides n! in base 10
    return ($count / 4);
}

// Driver code
$n = 6;
echo(getTrailingZeroes($n));

// This code is contributed by
// Code_Mech.

?>

Javascript

<script>

// JavaScript implementation of the approach

// Function to return the count of trailing zeroes
function getTrailingZeroes(n)
{
    let count = 0;
    let val, powerTwo = 2;

    // Implementation of the Legendre's formula
    do {
        val = Math.floor(n / powerTwo);
        count += val;
        powerTwo *= 2;
    } while (val != 0);

    // Count has the highest power of 2
    // that divides n! in base 10
    return (Math.floor(count / 4));
}

// Driver code

    let n = 6;
    document.write(getTrailingZeroes(n));


// This code is contributed by Surbhi Tyagi

</script>

Output

1

Time Complexity: O(log n) 
Auxiliary Space: O(1)