1. public class Test8
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int num=1;
   
6.                 int z=0;
   
7.         //2*5则会多一个0，因为在1-1000中因数2的数量足够多，则只需求因数5的个数即可
   
8.                 for(int i=1;i<=1000;i++)
   
9.                 {
   
10.                                 //求出1000中所有5的倍数的值
    
11.                                 num=5*num;
    
12.                                 //判断5的个数
    
13.                                 if(0<num && num<1000)
    
14.                                         {
    
15.                                 //将1000个数中不同的5的倍数中的因数5的个数相加
    
16.                                                 z=1000/num+z;
    
17.                                         }
    
18.                 }
    
19.                         //因数5的个数即为0的个数
    
20.                         System.out.print(z);
    
21.         }
    
22. }

复制代码

这个数学思想，没有明白，请朋友们给讲下



我的思想是 先算1~1000的乘积，把乘积转换成字符串，在通过方法知道后边有多少个零，

亲们，你们能写出我想的这个代码吗？  Ps：int 是有范围的。求解答

累加乘势什么

这个问题我给你解答  因为我就是这么写的 确实如此int的话范围不够 无法得出1000！这样大的数
但是java里面给我提供了一个专门计算大数的类型就是bigInteger 怎么很直观吧 大整型  下面就看具体代码吧 关于bigInteger有什么疑问的话可以查看API文档哈他的方法有哪些怎么用都有的

1. public static void main(String[] args) {
   
2.                 BigInteger bi = new BigInteger("1");//初始化值为1
   
3.                 for(int i=2;i<1001;i++){
   
4.                         bi=bi.multiply(BigInteger.valueOf(i));//这里是做乘法运算
   
5.                 }
   
6.                 int N=0;
   
7.                 String s=bi.toString();//结果转化为字符串
   
8.                 for(int i=0;i<s.length();i++){
   
9.                         if(s.charAt(i)=='0'){
   
10.                                 N++;//有一个0就加上1
    
11.                         }
    
12.                 }
    
13.                 System.out.println("1000！中共有0的个数为："+N);
    
14.         }

复制代码

简单  容易理解 希望采纳 谢谢

最开始恢复了不知道为什么说要审查一直都没下来 重新给你写一个吧  我直接贴上我自己写的代码 这里用到一个bigInteger的类型很直观就是大整型 没有上限只要你内存足够大 数字可以无限大 下面是代码 具体用发可以私聊或者你去查API都没问题

1. public static void main(String[] args) {
   
2.                 BigInteger bi = new BigInteger("1");//初始化值为1
   
3.                 for(int i=2;i<1001;i++){
   
4.                         bi=bi.multiply(BigInteger.valueOf(i));//这里是做乘法运算
   
5.                 }
   
6.                 int N=0;
   
7.                 String s=bi.toString();//结果转化为字符串
   
8.                 for(int i=0;i<s.length();i++){
   
9.                         if(s.charAt(i)=='0'){
   
10.                                 N++;//有一个0就加上1
    
11.                         }
    
12.                 }
    
13.                 System.out.println("1000！中共有0的个数为："+N);
    
14.         }

复制代码

留名以后做

字符串的代码是这样的，不知道是这个意思不？

1. class Test
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int sum=0;
   
6.                 //定义计数器
   
7.                 int count=0;
   
8. 
   
9.                 //计算1-1000的和
   
10.                 for (int i=0;i<1000 ; i++)
    
11.                 {
    
12.                         sum=sum+i;
    
13.                 }
    
14.                
    
15.                 //转换成字符串
    
16.                 String s =new Integer(sum).toString();
    
17.                
    
18.                 //转换成字符数组
    
19.                 char[] ch =s.toCharArray();
    
20. 
    
21.                 //从后往前遍历数组，如果为0计数器+1
    
22.                 for (int i =ch.length-1;i>0;i-- )
    
23.                 {
    
24.                         if(ch[i]=='0')
    
25.                                 count++;
    
26.                                
    
27.                 }
    
28.                         System.out.println("0的个数两个"count);
    
29.         }
    
30. }

复制代码

李维奥 发表于 2014-5-23 21:49
字符串的代码是这样的，不知道是这个意思不？

一楼说的是乘法  我刚开始也看了一下写出了大部分代码 但是在容器那里卡住了

1. import java.math.*;
   
2. public class Text9 {
   
3.         public static void main(String[] args) {
   
4.                 int num=1000;
   
5. 
   
6.                 //定义一个大整数，存储1000！的结果
   
7.                 BigInteger res=new BigInteger("1");
   
8.                 for(int i=1;i<=num;i++)
   
9.                 {
   
10. 
    
11.                         //计算1000！的阶层,将结果存储在res中
    
12.                         BigInteger number=new BigInteger(String.valueOf(i));
    
13.                         res=res.multiply(number);
    
14.                 }
    
15. 
    
16.                 //将结果转换成字符串，存在S中
    
17.                 String s=res.toString();
    
18.                 System.out.println(num+"!的结果是：");
    
19.                 System.out.println(s);
    
20.                 //count统计0的个数
    
21.                 int count=0;
    
22.                 for (int i = 0; i < s.length(); i++) {
    
23. 
    
24.                         //遍历字符串中的所有字符，如果字符为0，count++
    
25.                         if(s.charAt(i)=='0')
    
26.                                 count++;                       
    
27.                 }System.out.println(num+"!中共有："+count+"个0");       
    
28.         }
    
29. }

复制代码

//int只能存储32位，要用大整数BigInteger，这个代码可以算出来哦，希望可以帮到你

1. import java.math.*;
   
2. public class Text9 {
   
3.         public static void main(String[] args) {
   
4.                 int num=1000;
   
5. 
   
6.                 //定义一个大整数，存储1000！的结果
   
7.                 BigInteger res=new BigInteger("1");
   
8.                 for(int i=1;i<=num;i++)
   
9.                 {
   
10. 
    
11.                         //计算1000！的阶层,将结果存储在res中
    
12.                         BigInteger number=new BigInteger(String.valueOf(i));
    
13.                         res=res.multiply(number);
    
14.                 }
    
15. 
    
16.                 //将结果转换成字符串，存在S中
    
17.                 String s=res.toString();
    
18.                 System.out.println(num+"!的结果是：");
    
19.                 System.out.println(s);
    
20.                 //count统计0的个数
    
21.                 int count=0;
    
22.                 for (int i = 0; i < s.length(); i++) {
    
23. 
    
24.                         //遍历字符串中的所有字符，如果字符为0，count++
    
25.                         if(s.charAt(i)=='0')
    
26.                                 count++;                       
    
27.                 }System.out.println(num+"!中共有："+count+"个0");       
    
28.         }
    
29. }

复制代码

//用大整数可以存哦，希望可以帮到你

1. import java.math.*;
   
2. public class Text9 {
   
3.         public static void main(String[] args) {
   
4.                 int num=1000;
   
5. 
   
6.                 //定义一个大整数，存储1000！的结果
   
7.                 BigInteger res=new BigInteger("1");
   
8.                 for(int i=1;i<=num;i++)
   
9.                 {
   
10. 
    
11.                         //计算1000！的阶层,将结果存储在res中
    
12.                         BigInteger number=new BigInteger(String.valueOf(i));
    
13.                         res=res.multiply(number);
    
14.                 }
    
15. 
    
16.                 //将结果转换成字符串，存在S中
    
17.                 String s=res.toString();
    
18.                 System.out.println(num+"!的结果是：");
    
19.                 System.out.println(s);
    
20.                 //count统计0的个数
    
21.                 int count=0;
    
22.                 for (int i = 0; i < s.length(); i++) {
    
23. 
    
24.                         //遍历字符串中的所有字符，如果字符为0，count++
    
25.                         if(s.charAt(i)=='0')
    
26.                                 count++;                       
    
27.                 }System.out.println(num+"!中共有："+count+"个0");       
    
28.         }
    
29. }

复制代码

要用大整数来存储就可以了，我的基础题测试也有这个

大家看看我的做法怎么样，感觉效率比较高，（不建议全部算出来，因为要的只是零的个数，字符运算效率低，望采纳！

1. public class test {
   
2.          public static void main(String[] args)  {
   
3.          int mul=1,num=0,end=1000;
   
4.           for(int i=2;i<=end;i++) {
   
5.                  mul=mul*i;
   
6.                  //除去乘积后面所有0，并累加这些0
   
7.                  while(mul%10==0){
   
8.                      mul=mul/10;
   
9.                          num++;
   
10.                  }
    
11.                  //取得最后四位非零数字，因为下一个乘积末尾是否有0只与末尾四位数有关
    
12.                  mul=mul%1000;
    
13.            }
    
14.          System.out.println(end+"的阶乘，共有"+num+"个零");
    
15. }
    
16. 
    
17. }
    

复制代码

经过无数次的调试，现在可以用了

楼主看一下吧，个人觉得比较好理解

1. 
   
2. public class Jiecheng {
   
3. 
   
4.         public static void main (String args[])
   
5.         {
   
6.                 //M为要测试的范围1-M，这里假定最大是四位数的
   
7.                 int m=100;
   
8.                 //一下变量分别计末尾为5，0，00，000的数的个数
   
9.                 int count5 =0;
   
10.                 int count0 = 0;
    
11.                 int count00 =0;
    
12.                 int count000 =0;
    
13.                 //遍历整个范围 ，求个各个变量的值
    
14.                 for(int i=1;i<=m;i++)
    
15.                         {        if(i%1000==0)
    
16.                                 {
    
17.                                         count000++;
    
18.                                         continue;
    
19.                                 }
    
20.                                 if(i%100==0)
    
21.                                 {
    
22.                                         count00++;
    
23.                                         continue;
    
24.                                 }
    
25.                                 if(i%10==0)
    
26.                                 {
    
27.                                         count0++;
    
28.                                         continue;
    
29.                                 }
    
30.                                 if(i%5==0)
    
31.                                 {
    
32.                                         count5++;
    
33.                                         continue;
    
34.                                 }
    
35.                         }
    
36.                
    
37.                 //每一个整千的数会带来三个0，整百的会带来两个，整十的会带来一个，而由于数据中有充足的2和2的倍数存在，所以每一个五也会有一个0
    
38.                 //所以输出如下
    
39.                 System.out.println("0的个数为"+(count000*3+count00*2+count0+count5));
    
40.         }       
    
41. }
    

复制代码

Aron 发表于 2014-5-23 18:18
这个问题我给你解答  因为我就是这么写的 确实如此int的话范围不够 无法得出1000！这样大的数
但是java里 ...

明白了，赞

李维奥 发表于 2014-5-23 21:49
字符串的代码是这样的，不知道是这个意思不？

你这个和楼上的思想一样，只是int型是有范围的  累加乘的话，定义int是不行的

算出结果？那得多大数字？

学习一下。

Aron 发表于 2014-5-23 18:18
这个问题我给你解答  因为我就是这么写的 确实如此int的话范围不够 无法得出1000！这样大的数
但是java里 ...

这个方法最容易理解！很赞哦！

gentleman 发表于 2014-5-24 07:22
大家看看我的做法怎么样，感觉效率比较高，（不建议全部算出来，因为要的只是零的个数，字符运算效率低，望 ...

确实精简高效！

铁血丹心 发表于 2014-5-25 00:24
楼主的程序我也没看懂，自己写的，思路写的长点，大家好看一些。大家看一下有啥不对的地方没 ...

这么帅的思路。代码很精辟。

不是很懂啊