1*2*3*4....*999*1000中含有多少零？

我也在做这个题  我也想问问 1000！的末尾有几个零呢   

这个好像定义长整型都存不下。大概在66的时候就溢出了。
public class Demo {
        public static void main(String [] args)
        {
                long sum=1l;int count=0;
                for(int i=1;i<=65;i++)
                {
                       
                        sum=i*sum;
                       
                }
                System.out.println(sum);
        }

}

结果：-9223372036854775808

求大神指导吧

个人认为只要查找1~1000中有多少个5的倍数就能迅速找到有几个零
个位5------------->100个
个位0,十位不为0------------->90个
整百------------------------->9个
整千--------------------->1个
这里面最难得是算5
大致思路是这样

硬算是算不了的，需要技巧。* 最后的结论是：可以转换成求1到1000中能被5整除并且因子是5的个数。
                 *
                 * 首先知道这，就可以只测试5的整数倍的数。
                 * 如果是5的倍数，就循环除以5再测试，只到不是5的整数倍为止，而每一次的测试就表示会有一个0的出现，count就自加1.
                 */

        public static void main(String[] args) {
               
                int count=0;//计数器

                for(int x = 1; x <= 1000; x++){
                        //只测试5的整数倍的数
                        if((x%5)==0){
                                count = test(x,count);
                        }
                }
                System.out.println(count);//结果显示249
        }
        public static int test(int num,int count){
                //如果num是5的整数倍
                //while( (num%5)==0 && (num/5) >=1 ){
                while( (num%5)==0){
                        count++;
                        num/=5;
                       
                        //625         625 125 25 5 1
                        //125        5x5x5
                        //30        5x6
                        //75        5x5x5
                        //15        3x5
                        //130        5x26
                }
                return count;
        }

1. package cn.itcast.bank;
   
2. 
   
3. public class test {
   
4.         public static void main(String[] args){
   
5.                 //跟基础测试题里面含7 。3的那道题没多大区别啊
   
6.                 //首先遍历获取全部的数字
   
7.                 int count = 0;
   
8.                 for(int i=1 ; i <= 1000; i++){
   
9.                         String s = String.valueOf(i);
   
10.                         //把数字转成字符,判读出所有含有0的字符
    
11.                         if(s.contains("0")){
    
12.                                 char c = '0';
    
13.                                 //把字符转换成char数组
    
14.                                 char[] chars = s.toCharArray();
    
15.                                 for(int j = 0; j < chars.length; j++)
    
16.                                  {
    
17.                                         //判断数组中每个字符是否为0
    
18.                                      if(c == chars[j])
    
19.                                      {
    
20.                                         count++;
    
21.                                            
    
22.                                      }
    
23.                             }
    
24.                         }else{
    
25.                                 System.out.println("没有0，我是"+ Integer.parseInt( s ));
    
26.                         }
    
27.                 }
    
28.                 System.out.println(count);
    
29.                
    
30.         }
    
31. }
    
32. 
    

复制代码

代码加注释，，介个不需要解释了吧。。。呵呵！

董振冬 发表于 2014-3-21 16:05
代码加注释，，介个不需要解释了吧。。。呵呵！

简单高效！

一共有237个0
具体思路：
在1~1000的数字中；一眼能看到带0的数字有整千，整百，整十，以及和5相乘的数
序列一：个位5-  100个）(15,25……)
序列二：个位0,十位不为0------------->90个--->90个0
序列三：整百------------------------->9个------>18个0
序列四：整千--------------------->1个----------->3个0
序列五：1~1000，除了整十整百整千，剩下的偶数；
所以现在能直观的看到111个0
在序列一中找我们有用的是5，所以全部分解，最后得到125个5
在序列二中找我们有用的，全部分解我们得到83个2
在序列三中，同理我们得到1个5，7个2
序列四没有有用的
序列五，得到了至少超过50个2
最后我们得到126个5，大于126个2，这样我们又得到126个0
最后一共237个0

1. public class Test5 {
   
2. 
   
3.         //计算能够被n整除的个数
   
4.         static int getDiv(int n){
   
5.                 int temp = 0;
   
6.                 for(int i = 1; i <= 1000; i++){
   
7.                         if(i%n == 0){
   
8.                                 temp++;
   
9.                         }
   
10.                 }
    
11.                 return temp;
    
12.         }
    
13.         public static void main(String[] args) {
    
14. 
    
15.                 int n = 5;
    
16.                 int num = 0;
    
17.                 //遍历5,25,125,625……不超过1000
    
18.                 for(int i = n; i <= 1000; i*=5){
    
19.                         num += getDiv(i);
    
20.                 }
    
21.                 System.out.println("!1000的末尾有"+num+"个零.");
    
22.         }
    
23. }

复制代码

其实只需要找总共有多少个5相乘即可。把所有5的倍数拆开，计算该倍数有几个5相乘，同理，求2的个数，（为什么要求5和2的个数呢？因为5x2=10 啊！！！）但是2的个数明显比5多，所以，计算5即可！例如：15=3x5 (一个5)；   25=5x5 （两个5），如此类推！

上面有几个程序都是这个原理！！

1. public class Test{
   
2. 
   
3. //     计算5的倍数中有几个5相乘！返回个数！
   
4.         static int getNumbleOf(int n){
   
5.                
   
6.       int num=0;
   
7.       while((n%5)==0){
   
8.                      
   
9.           n=n/5;
   
10.           num++;        
    
11.          
    
12.       }
    
13.                    return num;
    
14.    }
    
15.    public static void main(String[] args) {
    
16. 
    
17.        int num = 0;
    
18.                
    
19.        for(int i = 1; i <=1000; i++){
    
20.                         
    
21.            if((i%5)==0){                                      //筛选5的倍数
    
22.                      
    
23.                num += getNumbleOf(i);
    
24.            }
    
25.        }
    
26.        System.out.println("!1000的末尾有"+num+"个零.");
    
27.    }
    
28. }

复制代码

谢谢支持