求赐教!!!

铁血丹心 发表于 2014-6-19 23:20
我觉得结果中所有的0应该在结尾处。结尾处0的个数就是所有的0的个数。

中间也是会出现0 的{:2_41:}

人心如水 发表于 2014-6-20 12:31
我的入学题做法，汉字改一下，
public class Test9 {
                public static void main(String[] args){

感谢哈 ,通过你和楼上的支招,我已经写出来了:handshake

1. package com.itheima;
   
2. 
   
3. import java.math.BigInteger;
   
4. 
   
5. /*
   
6. *  求1000！的结果中包含多少个0？注：1000! = 1×2×3×4×5×...×999×1000
   
7. *  
   
8. *  思路:
   
9. *  1.利用for循环计算出1000!的结果,考虑到该值太大,所以使用BigInteger类型进行接收
   
10. *  2.将计算出的结果转换成字符串,再转换成字符数组
    
11. *  3.判断每一字符是否为'0',计算出最终0的个数
    
12. *  
    
13. */
    
14. public class Test9 {
    
15. 
    
16.         public static void main(String[] args) {
    
17. 
    
18.                 // 定义一个BigInteger类型变量i,用于存储最终计算的1000!的值,初始值为1
    
19.                 BigInteger i = new BigInteger("1");
    
20. 
    
21.                 // 利用for循环计算出最终的1000!的值
    
22.                 for (int j = 2; j < 1001; j++) {
    
23.                         i = i.multiply(BigInteger.valueOf(j));
    
24. 
    
25.                 }
    
26. 
    
27.                 // 利用BigInteger中的toString方法将i转换成String类型
    
28.                 String str = i.toString();
    
29. 
    
30.                 // 利用String类中的toCharArray方法将1000!结果中的每一个数存储到一个字符数组中
    
31.                 char[] ch = str.toCharArray();
    
32. 
    
33.                 // 利用否循环遍历并判断每一个字符是否为'0',为'0'则计数器+1;
    
34. 
    
35.                 int count = 0;// 定义一个计数器,用于纪录结果中0出现的次数
    
36.                 for (int j = 0; j < ch.length; j++) {
    
37.                         if (ch[j] == '0') {
    
38.                                 count++;
    
39.                         }
    
40. 
    
41.                 }
    
42.                 // 输出打印最终计算出的结果
    
43.                 System.out.println("在1000!的结果中0出现的次数为:" + count + "次!");
    
44. 
    
45.         }
    
46. }
    

复制代码

我的入学题做法，汉字改一下，
public class Test9 {
                public static void main(String[] args){
                        //因为1000！太大了，必须引入BigInteger类，建立对象并赋值为1
                        BigInteger sum = BigInteger.valueOf(1);
                        //调用下面的方法，得到sum的值
                        sum = factorial(sum);
                        //通过下面的方法获取结果中0的个数
                        System.out.println(getZeros(sum.toString()));
                }
                private  static BigInteger factorial(BigInteger sum){// 1000!
                                for(int i=1;i<1001;i++){
                                        //这里注意：i的类型必须转换，纠错了半天（***）
                                                sum = sum.multiply(BigInteger.valueOf(i));
                                }
                                //这里已经获取到了sum的值，是个BigInteger类型
                        return sum;
                }
                //获取0个数的方法
                private static int  getZeros(String str){//get zeros
                        //利用split方法將字符串以"0"切割，转换为字符串数组
                        String[] split = str.split("0");
                        int size = 0;
                        //高级for循环完成遍历出非0的长度
                        for (String string : split) {
                                size = size + string.length();
                        }
                        //返回0的个数
                        return str.length() - size ;
                }
}public class Test9 {
                public static void main(String[] args){
                        //因为1000！太大了，必须引入BigInteger类，建立对象并赋值为1
                        BigInteger sum = BigInteger.valueOf(1);
                        //调用下面的方法，得到sum的值
                        sum = factorial(sum);
                        //通过下面的方法获取结果中0的个数
                        System.out.println(getZeros(sum.toString()));
                }
                private  static BigInteger factorial(BigInteger sum){// 1000!
                                for(int i=1;i<1001;i++){
                                        //这里注意：i的类型必须转换，纠错了半天（***）
                                                sum = sum.multiply(BigInteger.valueOf(i));
                                }
                                //这里已经获取到了sum的值，是个BigInteger类型
                        return sum;
                }
                //获取0个数的方法
                private static int  getZeros(String str){//get zeros
                        //利用split方法將字符串以"0"切割，转换为字符串数组
                        String[] split = str.split("0");
                        int size = 0;
                        //高级for循环完成遍历出非0的长度
                        for (String string : split) {
                                size = size + string.length();
                        }
                        //返回0的个数
                        return str.length() - size ;
                }
}

编程学徙 发表于 2014-6-19 23:41
哦，不好意思，刚刚没看清楚题意，根据你的要求，作了如下更改，希望可以帮到你。。
下面是运行结果：

灰常感谢你的用心回答,感谢感谢!:handshake

铁血丹心 发表于 2014-6-19 23:20
我觉得结果中所有的0应该在结尾处。结尾处0的个数就是所有的0的个数。

哦，不是，中间也为0，0的总个数为：472，结尾处0的个数为：249

哦，不好意思，刚刚没看清楚题意，根据你的要求，作了如下更改，希望可以帮到你。。

1. import java.math.BigInteger;
   
2. import java.util.*;
   
3. 
   
4. /**
   
5. 此程序用以输出1000的阶乘，并统计其尾部0的个数，这是对BigInteger类的一个综合练习。
   
6. 步骤：
   
7. 1、先求出1000的阶乘；
   
8. 2、用结果自身除以10，jishu自增1；
   
9. 3、判断结果除以10之后的余数是否为0，如果是，返回第2步，如果不是，执行第4步；
   
10. 4、输出计数结果。
    
11. */
    
12. 
    
13. public class BigDemo2
    
14. {
    
15.         public static void main(String[] args)
    
16.         {
    
17.                 int i;
    
18.                 BigInteger result = new BigInteger("1");                                        //1000!是一个大数据，需要用BigInteger来保存；
    
19.                 for(i=1;i<=1000;i++)
    
20.                 {
    
21.                         result = result.multiply(BigInteger.valueOf(i));
    
22.                         //a.multiply(b):大数据的乘法表示方法；
    
23.                         //int型变量要参数大数据运算，要用BigInteger.valueof()来做转换。
    
24.                 }
    
25.         //        System.out.println("1000! = "+result);
    
26.                 String re = result.toString();
    
27.                 System.out.println("1000! = "+re);
    
28.                 int[] reArray = new int[re.length()];
    
29.                 for(i=0;i<re.length();i++)
    
30.                 {
    
31.                         reArray[i] = Integer.parseInt(String.valueOf(re.charAt(i)));
    
32.                 }                                                                                                                        //将结果转换成一个字符串，再将字符串转换成一个int型的数组；
    
33.                 int zongShu = 0;
    
34.                 for(i=0;i<re.length();i++)
    
35.                 {
    
36.                         if(reArray[i] == 0)
    
37.                         {
    
38.                                 zongShu++;
    
39. 
    
40.                         }
    
41.                 }                                                                                                                        //遍历数组，然后统计所有0的个数；
    
42.                 int jishu = 0;                                                                                                //jishu用以统计0的个数。
    
43.                 BigInteger ten = new BigInteger("10");
    
44.                 BigInteger zero = new BigInteger("0");
    
45.                 BigInteger z = new BigInteger("0");                                                        //z的作用是用来存储result除以10之后的余数。
    
46.                 do
    
47.                 {                       
    
48.                         result = result.divide(ten);                                                        //a.divide(b):大数据的除法表示方法。
    
49.                         jishu++;
    
50.                         z = result.mod(ten);
    
51.                 }while(z.compareTo(zero) == 0);                                                                //a.compareTo(b):比较两个大数据的大小，如果相等，返回值为0。
    
52.                 System.out.println("尾部0的个数为："+jishu);
    
53.                 System.out.println("0的总个数为："+zongShu);
    
54.                
    
55.         }
    
56. }
    
57. 
    
58. 
    
59. 
    
60. /*
    
61. 呃……基础有限，怎么把字符串转换成int型数组还没学，这是网上查的方法。感谢网友解答啊!
    
62. int[] intarry=new int[sub.length()];
    
63.   for(int i=0;i<sub.length();i++)
    
64.   {
    
65.    intarry[i]=Integer.parseInt(String.valueOf(sub.charAt(i)));
    
66.   }*/

复制代码

下面是运行结果：

我觉得结果中所有的0应该在结尾处。结尾处0的个数就是所有的0的个数。

http://bbs.itheima.com/thread-123315-1-1.html
这是我前几天做的，供你参考一下。。