Question

import java.util.Scanner;
import java.io.*;
class factorial {

    void fact(int a) {
        int i;
        int ar[] = new int[10000];
        int fact = 1, count = 0;
        for (i = 1; i <= a; i++) {

            fact = fact * i;
        }
        String str1 = Integer.toString(fact);
        int len = str1.length();
        i = 0;
        do {
            ar[i] = fact % 10;
            fact /= 10;
            i++;
        } while (fact != 0);
        for (i = 0; i < len; i++) {
            if (ar[i] == 0) {
                count = count + 1;
            }
        }
        System.out.println(count);
    }
    public static void main(String...ab) {
        int a;
        Scanner input = new Scanner(System.in);
        a = input.nextInt();
        factorial ob = new factorial();
        ob.fact(a);
    }
}

此代码最多可以a = 10，但输入的数字大于a = 16后，它会给出错误的答案。请帮忙。由于我不能发布这个问题，如果我不为这个问题添加更多信息，但我认为我上面提供的信息足以支持我的想法。

Answer 1

与许多这些数学难题一样，您需要简化问题以使其变得实用。您需要在阶乘中找到十个幂的幂，而不是计算阶乘，然后找到尾随零的数量。

最简单的解决方案是计算五个权力的数量。你只需要计算5的幂就是因为在它之间有很多偶数来制作10。例如，5！有一个0,10！有2个，15个！有三个，20个！有四个，25个！不是五个而是六个，因为25 = 5 * 5.

简而言之，您只需要计算1到N之间的5的幂数。

// floor(N/5) + floor(N/25) + floor(N/125) + floor(N/625) ...
public static long powersOfTenForFactorial(long n) {
    long sum = 0;
    while (n >= 5) {
       n /= 5;
       sum += n;
    }
    return sum;
}

注意：这将计算Long.MAX_VALUE的尾随零！在一秒钟的派系中，无论你有多少记忆，用BigInteger尝试这个都不合适。

Answer 2

请注意，这不是其他人建议的数学解决方案，这只是对他最初所做的事情的重构......

这里我只使用BigInteger代替Int，并简化了代码abit。您的解决方案仍然不是最佳的。我想我会告诉你你发布的重构版本是什么样的。你的初始功能也有一个错误。它返回整数中的零数，而不仅仅是尾随零的数量。

import java.math.BigInteger;
import java.util.Scanner;

class factorial {

    public static void main(String... ab) {
        Scanner input = new Scanner(System.in);
        int a = input.nextInt();
        fact(a);
    }

    private static void fact(int a) {
        BigInteger fact = BigInteger.ONE;
        int i, count = 0;
        for (i = 1; i <= a; i++) {
            fact = fact.multiply(new BigInteger(Integer.toString(i)));
        }
        String str1 = fact.toString();
        for(int j = str1.length() - 1; j > -1; j--) {
            if(Character.digit(str1.charAt(j), 10) != 0) {
                System.out.println(count);
                break;
            } else {
                count++;
            }
        }
    }
}

Answer 3

不使用factorial

public class TrailingZero {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    System.out.println(trailingZeroes(9247));

}

public static int trailingZeroes(int a) {
    int count = 0;
    int countTwo = 0;
    int countFive = 0;

    for (int i = a; i > 1; i--) {
        int localTwo = 0;
        int local = i;
        while (local > 1) {
            if (local % 2 != 0) {
                break;
            }

            local = local / 2;
            localTwo++;

        }

        countTwo += localTwo;
        int localFive = 0;
        while (local > 1) {
            if (local % 5 != 0) {
                break;
            } else {
                local = local / 5;
                localFive++;
            }

        }

        countFive += localFive;

    }

    if (countTwo == countFive) {
        count = count + countFive;
    } else if (countTwo > countFive) {
        count = count + countFive;
    } else if (countFive > countTwo) {
        count = count + countTwo;
    }

    return count;
}}

java中factorial中的数字尾随零

3 个答案: