Leetcode 阶乘后的零【Java&Golang&Rust】

阶乘后的零

题目描述

给定一个整数 n ，返回 n! 结果中尾随零的数量。

提示 n! = n * (n - 1) * (n - 2) * … * 3 * 2 * 1

示例

示例 1：

输入：n = 3
输出：0
解释：3! = 6 ，不含尾随 0

示例 2：

输入：n = 5
输出：1
解释：5! = 120 ，有一个尾随 0

示例 3：

输入：n = 0
输出：0

提示：

0 <= n <= 10⁴

解题思路

1. 0的贡献来源于：本身有0，或是偶数与5的倍数相乘获得；
2. 由于偶数的个数一定比5的倍数的个数多，因而对于这种情况只考虑5的倍数的个数
3. 本身有0的数恰好是5的倍数，拥有的0的个数恰好又与是5^n的倍数的n相等
4. 综上，只需要计算阶乘中各个5的次方数的个数和即可。【因为是多少次方就会在其中被计算多少次，因而不需要考虑是否会有重复计算的问题】

Java实现

import java.util.Scanner;

/**
 * @author wyf
 * @datetime 2023/6/1 21:08
 **/
public class Main {


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        System.out.println(trailingZeroes(n));
    }

    private static long a(int n) {
        long sum = 1;
        for (int i = 1; i <= n; i++) {
            sum *= i;
        }
        return sum;
    }

    public static int trailingZeroes(int n) {
        int count=0;
        while (n >=5){
            n = n/5;
            count+=n;
        }
        return count;
    }
}

Golang实现

package main

import "fmt"

func main() {
	var n int
	fmt.Scan(&n)
	fmt.Println(trailingZeroes(n))
}

func trailingZeroes(n int) int {
	count := 0
	for n >= 5 {
		n /= 5
		count += n
	}
	return count
}

Rust实现

use std::io;

pub fn main() {
    let mut input = String::new();
    io::stdin().read_line(&mut input)
        .ok()
        .expect("Failed to read line");
        
    let i: i32 = match input.trim().parse() {
        Ok(num) => num,
        Err(_) => {
             println!("请输入整数，请勿输入无关符号！");
             return;
        }
    };

    println!("{}", trailing_zeroes(i))
    
}

fn trailing_zeroes(m : i32) -> i32{
    let mut count = 0;
    let mut n = m;
    while n>=5 {
        n/=5;
        count+=n;
    }
    return count;
}