求1000！中有多少个0。 1000！倒是好求，就是求有多少个0难住了， 我的想法是定义一个常量为0，遍历结果中的每个数，后来发现如果这是个数组这种方法可行，但是是一个数，就不知道怎么做了，求大神解答？

我的思路：定义一个静态统计量，将1000转成字符数组，然后遍历数组，将数组元素为0的，统计量+1

因为偶数的个数大于5的倍数的个数，所以碰到5的倍数一定产生一个0，只要判断1000里面有多少个数是5的倍数，末尾就有多少个0。例如5!=120,一个0；10!=3 628 800,两个0.

String str = String.valueOf(i);
if(str.contains(0))
          for (int j = 0; ; j++) {
                str = str.substringstr.lastIndexOf("0"),);
                sum_0 = sum_0 + 1;
         }
         System.out.println(i+“中不包含”+sum_0+“个零”)；
}else{  
              System.out.println(i+“中不包含0”)；
}

楼主看我发的帖子里有一篇就是讲这个的

package com.xiangying;

public class Demo {

        /**
         * 求1000！中有多少个0。
         */
        public static void main(String[] args) {
                int []arr=getArr(1000);
                int count=getCount(arr);
                System.out.println(count);

        }
//定义一个方法：把每位数拆解到一个数组
        public static int [] getArr(int  number){
               
                int []arr=new int[4] ;
                int index=0;
                while(index<arr.length){
                        arr[index]=number%10;
                        index++;
                        number/=10;
                }
               
        return arr;       
               
        }
        //定义一个可以计算多少个0的方法
        public static int getCount(int [] arr){
                int count=0;
                for(int x=0;x<arr.length;x++){
                        if(arr[x]==0){
                                count++;
                        }
                }
                return count;
        }
}

*分析：
*首先要直接求1000！是不现实的，结果很容易就溢出了。因此，需要换另一种思考方式。
*如果N!=K*（10的Ｍ次幂）,且K不能被10整除,那么N!的结尾就有M个0。0的产生归根结底就
*是由于2和5的相乘，因此对N!进行质因数分解：N!=（2的X次幂）*（3的Y次幂）*（5的Z次幂）*...，
*由于10=2*5，所以M只与X和Z相关，M=min(X,Z)，因为能被2整除的数出现的频率比能被5整除的数多很多，
*所以只要求出Z的值就可以得到0的个数了。Z的值就是1到1000中所包含5的个数。
*/

public class Test {
        public static void main(String[] args) {
                System.out.println(countZeros(1000));//打印1000！末尾0的个数
               
        }
        /**
         * 求一个数的阶乘末尾0的个数
         * @param N 正整数
         * @return 0的个数
         */
    public static int countZeros(int N){
            int count = 0;//记录5的个数
            //遍历1到N，求解5的个数
            for(int i = 1;i <= N;i++){
                    int j = i;//临时变量，保存i的值
                    while(j % 5 == 0){//如果能被5整除，5的个数加1
                            count++;
                            j = j / 5;//得到j除以5以后的数，作为下一回循环的开始值
                    }       
            }
            return count;//返回5的个数，也就是末尾0的个数
    }
}

1. /*
   
2. 问题：求1000！中有多少个0。
   
3. 思路：
   
4. 1.定义一个字符串类型保存该计算式
   
5. 2.用字符串的索引第一次出现的位置，然后在该位置+1在进行索引，
   
6. [code]
   
7. [code]/*
   
8. 问题：求1000！中有多少个0。
   
9. 思路：
   
10. 1.将整数类型，转换为字符串类型。
    
11. 2.用字符串的索引第一次出现的位置，然后在该位置+1在进行索引，
    
12. */

复制代码

1. [code]
   
2. class Demo
   
3. {
   
4.         public static void main()
   
5.         {
   
6.                 int x =zero(chenJie(1000));
   
7.                 Syste.out.println(x);
   
8.         }
   
9.         public static String chenJie(int i)
   
10.         {
    
11.                 float sum=1;
    
12.         for(int x=1;x<=i;x++)
    
13.                 {
    
14.                 sum*=x;       
    
15.                 }
    
16.          return(sum+"");
    
17.         }
    
18.         public static int zero(String str)
    
19.         {
    
20.                 int count=0;
    
21.                 int index=0;
    
22.                 for(int index=0;index<str.length();index++)
    
23.                 {
    
24.                    if(index=indexOf(str,index)!=-1)
    
25.                    count++;
    
26.                 }
    
27.                 return count;
    
28.         }
    
29. }
    
30. [code]
    

复制代码

你这哪来的题目

受教受教了