计算阶乘尾随零的Python方法详解

def factorial(x):
  if x==1:
    return x 
  else:
    return x*factorial(x-1)

def zeros(n):
  list1= list(str(factorial(n)))
  list2 = list1[:]
  for numbers in list1:  
    if numbers!=0: # 错误：字符串 '0' 与整数 0 比较
      list2.remove(numbers)
    else:
      # ... 复杂的逻辑，试图处理 '0' 的情况
      pass # 实际代码中还有更多复杂且不必要的逻辑
  return len("".join(list4)) # 这里的list4也未正确构建

def zeros_mathematical(n: int) -> int:
    """
    使用数学原理（勒让德公式）计算N!的尾随零数量。
    此方法对大N非常高效且准确，避免了数值溢出问题。
    """
    if n < 0:
        raise ValueError("阶乘的输入必须是非负整数。")
    if n == 0:
        return 0 # 0! = 1, 没有尾随零

    count = 0
    i = 5
    while i <= n:
        count += n // i
        # 避免 i * 5 溢出，或者直接更新 i 为 i * 5
        # 更好的做法是检查 i 是否能被 5 整除，或者直接用 n //= 5 简化
        # 简化版：
        # n //= 5
        # count += n
        # 另一种写法：
        # i *= 5
        # 循环条件可以改为 while n > 0: n //= 5; count += n

        # 经典写法：
        if n // i < 5 and i * 5 > n: # 优化：防止 i 增长过快或溢出
            break
        i *= 5
    return count

# 简化后的更常见写法
def zeros_mathematical_simplified(n: int) -> int:
    """
    更简洁的勒让德公式实现。
    """
    if n < 0:
        raise ValueError("阶乘的输入必须是非负整数。")
    if n == 0:
        return 0

    count = 0
    while n >= 5:
        n //= 5
        count += n
    return count

# 示例
print(f"zeros_mathematical_simplified(6): {zeros_mathematical_simplified(6)}")   # 输出: 1
print(f"zeros_mathematical_simplified(12): {zeros_mathematical_simplified(12)}") # 输出: 2
print(f"zeros_mathematical_simplified(20): {zeros_mathematical_simplified(20)}") # 输出: 4
print(f"zeros_mathematical_simplified(100): {zeros_mathematical_simplified(100)}") # 输出: 24

def calculate_factorial(x: int) -> int:
  """
  计算给定数字的阶乘。
  注意：对于大数N，此函数将产生非常大的结果，可能影响性能。
  """
  if x < 0:
    raise ValueError("阶乘的输入必须是非负整数。")
  if x == 0:
    return 1 # 0! 定义为 1

  res = 1
  for i in range(1, x + 1):
    res *= i
  return res

def zeros_string_manual(n: int) -> int:
    """
    通过计算阶乘、转换为字符串并手动反转计数开头零的方法。
    """
    if n < 0:
        raise ValueError("阶乘的输入必须是非负整数。")
    if n == 0:
        return 0 # 0! = 1, 没有尾随零

    factorial_n = calculate_factorial(n)

    # 将阶乘结果转换为字符串，然后反转
    # 字符串切片 `[::-1]` 是Python中反转字符串的常用技巧
    reversed_str = str(factorial_n)[::-1]

    count = 0
    for char in reversed_str:
        if char == "0":
            count += 1
        else:
            break # 遇到第一个非零字符即停止，因为我们只关心尾随零
    return count

# 示例
print(f"zeros_string_manual(6): {zeros_string_manual(6)}")   # 输出: 1
print(f"zeros_string_manual(12): {zeros_string_manual(12)}") # 输出: 2
print(f"zeros_string_manual(20): {zeros_string_manual(20)}") # 输出: 4

def zeros_string_enumerate(n: int) -> int:
    """
    通过计算阶乘、转换为字符串并使用enumerate反转计数开头零的方法。
    """
    if n < 0:
        raise ValueError("阶乘的输入必须是非负整数。")
    if n == 0:
        return 0 # 0! = 1, 没有尾随零

    factorial_n = calculate_factorial(n)

    # 转换为字符串并反转
    reversed_str = str(factorial_n)[::-1]

    # 遍历反转后的字符串，使用 enumerate 获取索引和字符
    for i, char in enumerate(reversed_str):
        if char != "0":
            return i # 遇到第一个非零字符，其索引 i 就是前面零的数量

    # 边界情况：如果数字本身就是0（例如，如果 factorial_n 结果为0，虽然阶乘不会为0），
    # 或者如果 reversed_str 是空字符串（不会发生），
    # 或者所有字符都是0（例如 "000"），则返回字符串长度。
    # 对于阶乘问题，不会出现所有字符都是0的情况。
    # 原始答案中的 `return 1 # case n = 0` 是针对一个特殊场景，
    # 即如果 n 本身是 0，但这里的 n 是阶乘的输入，0! = 1，所以不会出现这个情况。
    # 如果 factorial_n 恰好是 0（不可能发生），那么 reversed_str 也是 '0'，循环会返回 1。
    return len(reversed_str) # 如果所有字符都是 '0' (如 '0' -> '0')，返回其长度

# 示例
print(f"zeros_string_enumerate(6): {zeros_string_enumerate(6)}")   # 输出: 1
print(f"zeros_string_enumerate(12): {zeros_string_enumerate(12)}") # 输出: 2
print(f"zeros_string_enumerate(20): {zeros_string_enumerate(20)}") # 输出: 4